
// Generated from /home/chh/gitprojects/plc2llvm/grammar/PLCSTParser.g4 by ANTLR 4.11.1

#pragma once


#include "antlr4-runtime.h"


namespace plcst {


class  PLCSTParser : public antlr4::Parser {
public:
  enum {
    Unsigned_Int = 1, Signed_Int = 2, Binary_Int = 3, Octal_Int = 4, Hex_Int = 5, 
    Science_real = 6, Const_bool = 7, S_Byte_Char_Str = 8, D_Byte_Char_Str = 9, 
    Duration = 10, Interval = 11, Days = 12, Hours = 13, Minutes = 14, Seconds = 15, 
    Milliseconds = 16, Microseconds = 17, Nanoseconds = 18, Time_Of_Day = 19, 
    Daytime = 20, Day_Hour = 21, Day_Minute = 22, Day_Second = 23, Date = 24, 
    Date_Literal = 25, Year = 26, Month = 27, Day = 28, Date_And_Time = 29, 
    Int_Type_Name = 30, Real_Type_Name = 31, CHAR = 32, WCHAR = 33, SString_Type_Name = 34, 
    WString_Type_Name = 35, Time_Type_Name = 36, Date_Type_Name = 37, Bool_Type_Name = 38, 
    Multibits_Type_Name = 39, TYPE = 40, END_TYPE = 41, ARRAY = 42, OF = 43, 
    STRUCT = 44, END_STRUCT = 45, OVERLAP = 46, Direct_Variable = 47, REF_TO = 48, 
    Null = 49, REF = 50, THIS = 51, VAR_INPUT = 52, END_VAR = 53, RETAIN = 54, 
    NON_RETAIN = 55, R_EDGE = 56, F_EDGE = 57, VAR_OUTPUT = 58, VAR_IN_OUT = 59, 
    VAR = 60, CONSTANT = 61, VAR_TEMP = 62, VAR_EXTERNAL = 63, VAR_GLOBAL = 64, 
    AT = 65, STRING = 66, WSTRING = 67, Var_Location = 68, Std_Func_Name = 69, 
    FUNCTION = 70, END_FUNCTION = 71, Std_FB_Name = 72, FUNCTION_BLOCK = 73, 
    FINAL = 74, ABSTRACT = 75, EXTENDS = 76, IMPLEMENTS = 77, END_FUNCTION_BLOCK = 78, 
    METHOD = 79, END_METHOD = 80, OVERRIDE = 81, CLASS = 82, END_CLASS = 83, 
    INTERFACE = 84, END_INTERFACE = 85, PUBLIC = 86, PROTECTED = 87, PRIVATE = 88, 
    PROGRAM = 89, END_PROGRAM = 90, VAR_ACCESS = 91, INITIAL_STEP = 92, 
    END_STEP = 93, STEP = 94, ACTION_QUALIFIER = 95, ACTION_TIME_QUALIFIER = 96, 
    TRANSITION = 97, END_TRANSITION = 98, PRIORITY = 99, FROM = 100, ACTION = 101, 
    END_ACTION = 102, CONFIGURATION = 103, END_CONFIGURATION = 104, RESOURCE = 105, 
    ON = 106, END_RESOURCE = 107, Access_Direction = 108, TASK = 109, INTERVAL = 110, 
    SINGLE = 111, WITH = 112, VAR_CONFIG = 113, NAMESPACE = 114, INTERNAL = 115, 
    END_NAMESPACE = 116, USING = 117, OR = 118, XOR = 119, AND = 120, MOD = 121, 
    NOT = 122, Multibit_Part_Access = 123, SUPER = 124, RETURN = 125, IF = 126, 
    THEN = 127, ELSIF = 128, ELSE = 129, END_IF = 130, CASE = 131, END_CASE = 132, 
    EXIT = 133, CONTINUE = 134, FOR = 135, DO = 136, END_FOR = 137, TO = 138, 
    BY = 139, WHILE = 140, END_WHILE = 141, REPEAT = 142, UNTIL = 143, END_REPEAT = 144, 
    Identifier = 145, Whitespace = 146, Newline = 147, BlockComment = 148, 
    LineComment = 149, Dot = 150, Semi = 151, Colon = 152, Assign = 153, 
    LeftParen = 154, RightParen = 155, RangeDot = 156, Caret = 157, Comma = 158, 
    Underline = 159, TypeSign = 160, LeftBracket = 161, RightBracket = 162, 
    StarStar = 163, AndSign = 164, Equal = 165, NotEqual = 166, Less = 167, 
    Greater = 168, LessEqual = 169, GreaterEqual = 170, Plus = 171, Minus = 172, 
    Div = 173, QuestionEqual = 174, LeftAssign = 175, Star = 176
  };

  enum {
    RuleStartpoint = 0, RuleConstant = 1, RuleNumeric_Literal = 2, RuleInt_Literal = 3, 
    RuleReal_Literal = 4, RuleBool_Literal = 5, RuleChar_Str = 6, RuleWChar_Str = 7, 
    RuleChar_Literal = 8, RuleTime_Literal = 9, RuleBit_Str_Literal = 10, 
    RuleNumeric_Type_Name = 11, RuleString_Type_Name = 12, RuleBit_Str_Type_Name = 13, 
    RuleData_Type_Access = 14, RuleElem_Type_Name = 15, RuleNestedNameSpecifier = 16, 
    RuleDerived_Type_Access = 17, RuleStruct_Type_Access = 18, RuleData_Type_Decl = 19, 
    RuleType_Decl = 20, RuleSimple_Type_Decl = 21, RuleNested_Simple_Type_Decl = 22, 
    RuleSimple_Spec_Init = 23, RuleSimple_Spec = 24, RuleSubrange_Type_Decl = 25, 
    RuleSubrange_Spec_Init = 26, RuleSubrange_Spec = 27, RuleSubrange = 28, 
    RuleEnum_Type_Decl = 29, RuleNamed_Spec_Init = 30, RuleEnum_Spec_Init = 31, 
    RuleEnum_Value_Spec = 32, RuleEnum_Value = 33, RuleArray_Type_Decl = 34, 
    RuleArray_Spec_Init = 35, RuleArray_Spec = 36, RuleNested_Array_Type_Name = 37, 
    RuleDirect_Array_Type_Name = 38, RuleArray_Init = 39, RuleArray_Elem_Init = 40, 
    RuleMult_Array_Elem_Init_Value = 41, RuleArray_Elem_Init_Value = 42, 
    RuleStruct_Type_Decl = 43, RuleNested_Struct_Type_Decl = 44, RuleStruct_Spec = 45, 
    RuleStruct_Spec_Init = 46, RuleStruct_Decl = 47, RuleStruct_Elem_Decl = 48, 
    RuleStruct_Init = 49, RuleStruct_Elem_Init = 50, RuleStr_Type_Decl = 51, 
    RuleRef_Type_Decl = 52, RuleRef_Spec_Init = 53, RuleRef_Spec = 54, RuleRef_Type_Access = 55, 
    RuleRef_Value = 56, RuleRef_Addr = 57, RuleRef_Assign = 58, RuleRef_Deref = 59, 
    RuleVariable = 60, RuleSymbolic_Variable = 61, RuleVar_Access = 62, 
    RuleMulti_Elem_Var = 63, RuleSubscript_List = 64, RuleSubscript = 65, 
    RuleStruct_Variable = 66, RuleStruct_Elem_Select = 67, RuleInput_Decls = 68, 
    RuleInput_Decl = 69, RuleVar_Decl_Init = 70, RuleCommon_Var_Decl_Init = 71, 
    RuleEdge_Decl = 72, RuleRef_Var_Decl = 73, RuleInterface_Var_Decl = 74, 
    RuleVariable_List = 75, RuleArray_Conformand = 76, RuleArray_Conform_Decl = 77, 
    RuleFB_Decl_No_Init = 78, RuleFB_Spec_Init = 79, RuleFB_Instance_Name = 80, 
    RuleOutput_Decls = 81, RuleOutput_Decl = 82, RuleIn_Out_Decls = 83, 
    RuleIn_Out_Var_Decl = 84, RuleVar_Decl = 85, RuleArray_Var_Decl = 86, 
    RuleStruct_Var_Decl = 87, RuleVar_Decls = 88, RuleRetain_Var_Decls = 89, 
    RuleLoc_Var_Decls = 90, RuleLoc_Var_Decl = 91, RuleTemp_Var_Decls = 92, 
    RuleExternal_Var_Decls = 93, RuleExternal_Decl = 94, RuleGlobal_Var_Decls = 95, 
    RuleGlobal_Var_Decl = 96, RuleGlobal_Var_Spec = 97, RuleLoc_Var_Spec_Init = 98, 
    RuleLocated_At = 99, RuleStr_Var_Decl = 100, RuleS_Byte_Str_Var_Decl = 101, 
    RuleS_Byte_Str_Spec = 102, RuleD_Byte_Str_Var_Decl = 103, RuleD_Byte_Str_Spec = 104, 
    RuleLoc_Partly_Var_Decl = 105, RuleLoc_Partly_Var = 106, RuleVar_Spec = 107, 
    RuleFunc_Name = 108, RuleFunc_Access = 109, RuleFunc_Decl = 110, RuleIO_Var_Decls = 111, 
    RuleFunc_Var_Decls = 112, RuleFunc_Body = 113, RuleFB_Type_Name = 114, 
    RuleFB_Type_Access = 115, RuleFB_Decl = 116, RuleFB_IO_Var_Decls = 117, 
    RuleFB_Input_Decls = 118, RuleFB_Input_Decl = 119, RuleFB_Output_Decls = 120, 
    RuleFB_Output_Decl = 121, RuleOther_Var_Decls = 122, RuleNo_Retain_Var_Decls = 123, 
    RuleFB_Body = 124, RuleMethod_Decl = 125, RuleAccess_Spec = 126, RuleClass_Decl = 127, 
    RuleClass_Type_Access = 128, RuleClass_Instance_Name = 129, RuleInterface_Decl = 130, 
    RuleMethod_Prototype = 131, RuleInterface_Spec_Init = 132, RuleInterface_Value = 133, 
    RuleInterface_Name_List = 134, RuleInterface_Type_Access = 135, RuleProg_Decl = 136, 
    RuleProg_Type_Access = 137, RuleProg_Access_Decls = 138, RuleProg_Access_Decl = 139, 
    RuleSFC = 140, RuleSfc_Network = 141, RuleInitial_Step = 142, RuleStep = 143, 
    RuleAction_Association = 144, RuleAction_Qualifier = 145, RuleAction_Time = 146, 
    RuleTransition = 147, RuleSteps = 148, RuleTransition_Cond = 149, RuleAction = 150, 
    RuleConfig_Decl = 151, RuleResource_Decl = 152, RuleSingle_Resource_Decl = 153, 
    RuleAccess_Decls = 154, RuleAccess_Decl = 155, RuleAccess_Path = 156, 
    RuleGlobal_Var_Access = 157, RuleProg_Output_Access = 158, RuleTask_Config = 159, 
    RuleTask_Init = 160, RuleData_Source = 161, RuleProg_Config = 162, RuleProg_Conf_Elems = 163, 
    RuleProg_Conf_Elem = 164, RuleFB_Task = 165, RuleProg_Cnxn = 166, RuleProg_Data_Source = 167, 
    RuleData_Sink = 168, RuleConfig_Init = 169, RuleConfig_Inst_Init = 170, 
    RuleNamespace_Decl = 171, RuleNamespace_Elements = 172, RuleNamespace_H_Name = 173, 
    RuleUsing_Directive = 174, RulePOU_Decl = 175, RuleExpression = 176, 
    RuleConstant_Expr = 177, RuleXor_Expr = 178, RuleAnd_Expr = 179, RuleCompare_Expr = 180, 
    RuleEqu_Expr = 181, RuleAdd_Expr = 182, RuleTerm = 183, RulePower_Expr = 184, 
    RuleUnary_Expr = 185, RuleParen_Surrounded_Expr = 186, RulePrimary_Expr = 187, 
    RuleVariable_Access = 188, RuleCallable_Obj_Params_Assign = 189, RuleFunc_Call = 190, 
    RuleStmt_List = 191, RuleStmt = 192, RuleAssign_Stmt = 193, RuleVar_Assign = 194, 
    RuleAssignment_Attempt = 195, RuleInside_Callable_Obj = 196, RuleCallable_Obj = 197, 
    RuleInvocation = 198, RuleSubprog_Ctrl_Stmt = 199, RuleParam_Assign = 200, 
    RuleCommon_Param_Assign = 201, RuleRef_Param_Assign = 202, RuleOther_Param_Assign = 203, 
    RuleSelection_Stmt = 204, RuleIF_Stmt = 205, RuleCase_Stmt = 206, RuleCase_Selection = 207, 
    RuleCase_List = 208, RuleCase_List_Elem = 209, RuleIteration_Stmt = 210, 
    RuleFor_Stmt = 211, RuleFor_List = 212, RuleWhile_Stmt = 213, RuleRepeat_Stmt = 214, 
    RuleSimple_Type_Name = 215, RuleSubrange_Type_Name = 216, RuleEnum_Type_Name = 217, 
    RuleArray_Type_Name = 218, RuleStruct_Type_Name = 219, RuleStruct_Elem_Name = 220, 
    RuleRef_Name = 221, RuleRef_Type_Name = 222, RuleVariable_Name = 223, 
    RuleFB_Name = 224, RuleGlobal_Var_Name = 225, RuleDerived_Func_Name = 226, 
    RuleDerived_FB_Name = 227, RuleMethod_Name = 228, RuleClass_Type_Name = 229, 
    RuleClass_Name = 230, RuleInterface_Type_Name = 231, RuleProg_Type_Name = 232, 
    RuleStep_Name = 233, RuleAction_Name = 234, RuleTransition_Name = 235, 
    RuleConfig_Name = 236, RuleResource_Type_Name = 237, RuleResource_Name = 238, 
    RuleAccess_Name = 239, RuleProg_Name = 240, RuleTask_Name = 241, RuleNamespace_Name = 242, 
    RuleControl_Variable = 243, RuleIndicator_Name = 244, RuleIdentifier = 245
  };

  explicit PLCSTParser(antlr4::TokenStream *input);

  PLCSTParser(antlr4::TokenStream *input, const antlr4::atn::ParserATNSimulatorOptions &options);

  ~PLCSTParser() override;

  std::string getGrammarFileName() const override;

  const antlr4::atn::ATN& getATN() const override;

  const std::vector<std::string>& getRuleNames() const override;

  const antlr4::dfa::Vocabulary& getVocabulary() const override;

  antlr4::atn::SerializedATNView getSerializedATN() const override;


  class StartpointContext;
  class ConstantContext;
  class Numeric_LiteralContext;
  class Int_LiteralContext;
  class Real_LiteralContext;
  class Bool_LiteralContext;
  class Char_StrContext;
  class WChar_StrContext;
  class Char_LiteralContext;
  class Time_LiteralContext;
  class Bit_Str_LiteralContext;
  class Numeric_Type_NameContext;
  class String_Type_NameContext;
  class Bit_Str_Type_NameContext;
  class Data_Type_AccessContext;
  class Elem_Type_NameContext;
  class NestedNameSpecifierContext;
  class Derived_Type_AccessContext;
  class Struct_Type_AccessContext;
  class Data_Type_DeclContext;
  class Type_DeclContext;
  class Simple_Type_DeclContext;
  class Nested_Simple_Type_DeclContext;
  class Simple_Spec_InitContext;
  class Simple_SpecContext;
  class Subrange_Type_DeclContext;
  class Subrange_Spec_InitContext;
  class Subrange_SpecContext;
  class SubrangeContext;
  class Enum_Type_DeclContext;
  class Named_Spec_InitContext;
  class Enum_Spec_InitContext;
  class Enum_Value_SpecContext;
  class Enum_ValueContext;
  class Array_Type_DeclContext;
  class Array_Spec_InitContext;
  class Array_SpecContext;
  class Nested_Array_Type_NameContext;
  class Direct_Array_Type_NameContext;
  class Array_InitContext;
  class Array_Elem_InitContext;
  class Mult_Array_Elem_Init_ValueContext;
  class Array_Elem_Init_ValueContext;
  class Struct_Type_DeclContext;
  class Nested_Struct_Type_DeclContext;
  class Struct_SpecContext;
  class Struct_Spec_InitContext;
  class Struct_DeclContext;
  class Struct_Elem_DeclContext;
  class Struct_InitContext;
  class Struct_Elem_InitContext;
  class Str_Type_DeclContext;
  class Ref_Type_DeclContext;
  class Ref_Spec_InitContext;
  class Ref_SpecContext;
  class Ref_Type_AccessContext;
  class Ref_ValueContext;
  class Ref_AddrContext;
  class Ref_AssignContext;
  class Ref_DerefContext;
  class VariableContext;
  class Symbolic_VariableContext;
  class Var_AccessContext;
  class Multi_Elem_VarContext;
  class Subscript_ListContext;
  class SubscriptContext;
  class Struct_VariableContext;
  class Struct_Elem_SelectContext;
  class Input_DeclsContext;
  class Input_DeclContext;
  class Var_Decl_InitContext;
  class Common_Var_Decl_InitContext;
  class Edge_DeclContext;
  class Ref_Var_DeclContext;
  class Interface_Var_DeclContext;
  class Variable_ListContext;
  class Array_ConformandContext;
  class Array_Conform_DeclContext;
  class FB_Decl_No_InitContext;
  class FB_Spec_InitContext;
  class FB_Instance_NameContext;
  class Output_DeclsContext;
  class Output_DeclContext;
  class In_Out_DeclsContext;
  class In_Out_Var_DeclContext;
  class Var_DeclContext;
  class Array_Var_DeclContext;
  class Struct_Var_DeclContext;
  class Var_DeclsContext;
  class Retain_Var_DeclsContext;
  class Loc_Var_DeclsContext;
  class Loc_Var_DeclContext;
  class Temp_Var_DeclsContext;
  class External_Var_DeclsContext;
  class External_DeclContext;
  class Global_Var_DeclsContext;
  class Global_Var_DeclContext;
  class Global_Var_SpecContext;
  class Loc_Var_Spec_InitContext;
  class Located_AtContext;
  class Str_Var_DeclContext;
  class S_Byte_Str_Var_DeclContext;
  class S_Byte_Str_SpecContext;
  class D_Byte_Str_Var_DeclContext;
  class D_Byte_Str_SpecContext;
  class Loc_Partly_Var_DeclContext;
  class Loc_Partly_VarContext;
  class Var_SpecContext;
  class Func_NameContext;
  class Func_AccessContext;
  class Func_DeclContext;
  class IO_Var_DeclsContext;
  class Func_Var_DeclsContext;
  class Func_BodyContext;
  class FB_Type_NameContext;
  class FB_Type_AccessContext;
  class FB_DeclContext;
  class FB_IO_Var_DeclsContext;
  class FB_Input_DeclsContext;
  class FB_Input_DeclContext;
  class FB_Output_DeclsContext;
  class FB_Output_DeclContext;
  class Other_Var_DeclsContext;
  class No_Retain_Var_DeclsContext;
  class FB_BodyContext;
  class Method_DeclContext;
  class Access_SpecContext;
  class Class_DeclContext;
  class Class_Type_AccessContext;
  class Class_Instance_NameContext;
  class Interface_DeclContext;
  class Method_PrototypeContext;
  class Interface_Spec_InitContext;
  class Interface_ValueContext;
  class Interface_Name_ListContext;
  class Interface_Type_AccessContext;
  class Prog_DeclContext;
  class Prog_Type_AccessContext;
  class Prog_Access_DeclsContext;
  class Prog_Access_DeclContext;
  class SFCContext;
  class Sfc_NetworkContext;
  class Initial_StepContext;
  class StepContext;
  class Action_AssociationContext;
  class Action_QualifierContext;
  class Action_TimeContext;
  class TransitionContext;
  class StepsContext;
  class Transition_CondContext;
  class ActionContext;
  class Config_DeclContext;
  class Resource_DeclContext;
  class Single_Resource_DeclContext;
  class Access_DeclsContext;
  class Access_DeclContext;
  class Access_PathContext;
  class Global_Var_AccessContext;
  class Prog_Output_AccessContext;
  class Task_ConfigContext;
  class Task_InitContext;
  class Data_SourceContext;
  class Prog_ConfigContext;
  class Prog_Conf_ElemsContext;
  class Prog_Conf_ElemContext;
  class FB_TaskContext;
  class Prog_CnxnContext;
  class Prog_Data_SourceContext;
  class Data_SinkContext;
  class Config_InitContext;
  class Config_Inst_InitContext;
  class Namespace_DeclContext;
  class Namespace_ElementsContext;
  class Namespace_H_NameContext;
  class Using_DirectiveContext;
  class POU_DeclContext;
  class ExpressionContext;
  class Constant_ExprContext;
  class Xor_ExprContext;
  class And_ExprContext;
  class Compare_ExprContext;
  class Equ_ExprContext;
  class Add_ExprContext;
  class TermContext;
  class Power_ExprContext;
  class Unary_ExprContext;
  class Paren_Surrounded_ExprContext;
  class Primary_ExprContext;
  class Variable_AccessContext;
  class Callable_Obj_Params_AssignContext;
  class Func_CallContext;
  class Stmt_ListContext;
  class StmtContext;
  class Assign_StmtContext;
  class Var_AssignContext;
  class Assignment_AttemptContext;
  class Inside_Callable_ObjContext;
  class Callable_ObjContext;
  class InvocationContext;
  class Subprog_Ctrl_StmtContext;
  class Param_AssignContext;
  class Common_Param_AssignContext;
  class Ref_Param_AssignContext;
  class Other_Param_AssignContext;
  class Selection_StmtContext;
  class IF_StmtContext;
  class Case_StmtContext;
  class Case_SelectionContext;
  class Case_ListContext;
  class Case_List_ElemContext;
  class Iteration_StmtContext;
  class For_StmtContext;
  class For_ListContext;
  class While_StmtContext;
  class Repeat_StmtContext;
  class Simple_Type_NameContext;
  class Subrange_Type_NameContext;
  class Enum_Type_NameContext;
  class Array_Type_NameContext;
  class Struct_Type_NameContext;
  class Struct_Elem_NameContext;
  class Ref_NameContext;
  class Ref_Type_NameContext;
  class Variable_NameContext;
  class FB_NameContext;
  class Global_Var_NameContext;
  class Derived_Func_NameContext;
  class Derived_FB_NameContext;
  class Method_NameContext;
  class Class_Type_NameContext;
  class Class_NameContext;
  class Interface_Type_NameContext;
  class Prog_Type_NameContext;
  class Step_NameContext;
  class Action_NameContext;
  class Transition_NameContext;
  class Config_NameContext;
  class Resource_Type_NameContext;
  class Resource_NameContext;
  class Access_NameContext;
  class Prog_NameContext;
  class Task_NameContext;
  class Namespace_NameContext;
  class Control_VariableContext;
  class Indicator_NameContext;
  class IdentifierContext; 

  class  StartpointContext : public antlr4::ParserRuleContext {
  public:
    StartpointContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *EOF();
    std::vector<POU_DeclContext *> pOU_Decl();
    POU_DeclContext* pOU_Decl(size_t i);
    std::vector<Prog_DeclContext *> prog_Decl();
    Prog_DeclContext* prog_Decl(size_t i);
    std::vector<SFCContext *> sFC();
    SFCContext* sFC(size_t i);
    std::vector<Config_DeclContext *> config_Decl();
    Config_DeclContext* config_Decl(size_t i);

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  StartpointContext* startpoint();

  class  ConstantContext : public antlr4::ParserRuleContext {
  public:
    ConstantContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    Numeric_LiteralContext *numeric_Literal();
    Char_LiteralContext *char_Literal();
    Time_LiteralContext *time_Literal();
    Bit_Str_LiteralContext *bit_Str_Literal();
    Bool_LiteralContext *bool_Literal();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  ConstantContext* constant();

  class  Numeric_LiteralContext : public antlr4::ParserRuleContext {
  public:
    Numeric_LiteralContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    Int_LiteralContext *int_Literal();
    Real_LiteralContext *real_Literal();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Numeric_LiteralContext* numeric_Literal();

  class  Int_LiteralContext : public antlr4::ParserRuleContext {
  public:
    Int_LiteralContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *Signed_Int();
    antlr4::tree::TerminalNode *Binary_Int();
    antlr4::tree::TerminalNode *Octal_Int();
    antlr4::tree::TerminalNode *Hex_Int();
    antlr4::tree::TerminalNode *Int_Type_Name();
    antlr4::tree::TerminalNode *TypeSign();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Int_LiteralContext* int_Literal();

  class  Real_LiteralContext : public antlr4::ParserRuleContext {
  public:
    Real_LiteralContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *Science_real();
    antlr4::tree::TerminalNode *Real_Type_Name();
    antlr4::tree::TerminalNode *TypeSign();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Real_LiteralContext* real_Literal();

  class  Bool_LiteralContext : public antlr4::ParserRuleContext {
  public:
    Bool_LiteralContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *Const_bool();
    antlr4::tree::TerminalNode *Bool_Type_Name();
    antlr4::tree::TerminalNode *TypeSign();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Bool_LiteralContext* bool_Literal();

  class  Char_StrContext : public antlr4::ParserRuleContext {
  public:
    Char_StrContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *S_Byte_Char_Str();
    antlr4::tree::TerminalNode *STRING();
    antlr4::tree::TerminalNode *TypeSign();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Char_StrContext* char_Str();

  class  WChar_StrContext : public antlr4::ParserRuleContext {
  public:
    WChar_StrContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *D_Byte_Char_Str();
    antlr4::tree::TerminalNode *WSTRING();
    antlr4::tree::TerminalNode *TypeSign();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  WChar_StrContext* wChar_Str();

  class  Char_LiteralContext : public antlr4::ParserRuleContext {
  public:
    Char_LiteralContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    Char_StrContext *char_Str();
    WChar_StrContext *wChar_Str();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Char_LiteralContext* char_Literal();

  class  Time_LiteralContext : public antlr4::ParserRuleContext {
  public:
    Time_LiteralContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *Duration();
    antlr4::tree::TerminalNode *Time_Of_Day();
    antlr4::tree::TerminalNode *Date();
    antlr4::tree::TerminalNode *Date_And_Time();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Time_LiteralContext* time_Literal();

  class  Bit_Str_LiteralContext : public antlr4::ParserRuleContext {
  public:
    Bit_Str_LiteralContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *Unsigned_Int();
    antlr4::tree::TerminalNode *Binary_Int();
    antlr4::tree::TerminalNode *Octal_Int();
    antlr4::tree::TerminalNode *Hex_Int();
    antlr4::tree::TerminalNode *Multibits_Type_Name();
    antlr4::tree::TerminalNode *TypeSign();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Bit_Str_LiteralContext* bit_Str_Literal();

  class  Numeric_Type_NameContext : public antlr4::ParserRuleContext {
  public:
    Numeric_Type_NameContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *Int_Type_Name();
    antlr4::tree::TerminalNode *Real_Type_Name();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Numeric_Type_NameContext* numeric_Type_Name();

  class  String_Type_NameContext : public antlr4::ParserRuleContext {
  public:
    String_Type_NameContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *SString_Type_Name();
    antlr4::tree::TerminalNode *WString_Type_Name();
    antlr4::tree::TerminalNode *CHAR();
    antlr4::tree::TerminalNode *WCHAR();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  String_Type_NameContext* string_Type_Name();

  class  Bit_Str_Type_NameContext : public antlr4::ParserRuleContext {
  public:
    Bit_Str_Type_NameContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *Bool_Type_Name();
    antlr4::tree::TerminalNode *Multibits_Type_Name();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Bit_Str_Type_NameContext* bit_Str_Type_Name();

  class  Data_Type_AccessContext : public antlr4::ParserRuleContext {
  public:
    Data_Type_AccessContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    Elem_Type_NameContext *elem_Type_Name();
    Derived_Type_AccessContext *derived_Type_Access();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Data_Type_AccessContext* data_Type_Access();

  class  Elem_Type_NameContext : public antlr4::ParserRuleContext {
  public:
    Elem_Type_NameContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    Numeric_Type_NameContext *numeric_Type_Name();
    Bit_Str_Type_NameContext *bit_Str_Type_Name();
    String_Type_NameContext *string_Type_Name();
    antlr4::tree::TerminalNode *Date_Type_Name();
    antlr4::tree::TerminalNode *Time_Type_Name();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Elem_Type_NameContext* elem_Type_Name();

  class  NestedNameSpecifierContext : public antlr4::ParserRuleContext {
  public:
    NestedNameSpecifierContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    Namespace_NameContext *namespace_Name();
    antlr4::tree::TerminalNode *Dot();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  NestedNameSpecifierContext* nestedNameSpecifier();

  class  Derived_Type_AccessContext : public antlr4::ParserRuleContext {
  public:
    Derived_Type_AccessContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    Simple_Type_NameContext *simple_Type_Name();
    std::vector<NestedNameSpecifierContext *> nestedNameSpecifier();
    NestedNameSpecifierContext* nestedNameSpecifier(size_t i);
    Subrange_Type_NameContext *subrange_Type_Name();
    Enum_Type_NameContext *enum_Type_Name();
    Array_Type_NameContext *array_Type_Name();
    Struct_Type_NameContext *struct_Type_Name();
    String_Type_NameContext *string_Type_Name();
    Class_Type_NameContext *class_Type_Name();
    Ref_Type_NameContext *ref_Type_Name();
    Interface_Type_NameContext *interface_Type_Name();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Derived_Type_AccessContext* derived_Type_Access();

  class  Struct_Type_AccessContext : public antlr4::ParserRuleContext {
  public:
    Struct_Type_AccessContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    Struct_Type_NameContext *struct_Type_Name();
    std::vector<NestedNameSpecifierContext *> nestedNameSpecifier();
    NestedNameSpecifierContext* nestedNameSpecifier(size_t i);

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Struct_Type_AccessContext* struct_Type_Access();

  class  Data_Type_DeclContext : public antlr4::ParserRuleContext {
  public:
    Data_Type_DeclContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *TYPE();
    antlr4::tree::TerminalNode *END_TYPE();
    std::vector<Type_DeclContext *> type_Decl();
    Type_DeclContext* type_Decl(size_t i);
    std::vector<antlr4::tree::TerminalNode *> Semi();
    antlr4::tree::TerminalNode* Semi(size_t i);

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Data_Type_DeclContext* data_Type_Decl();

  class  Type_DeclContext : public antlr4::ParserRuleContext {
  public:
    Type_DeclContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    Simple_Type_DeclContext *simple_Type_Decl();
    Subrange_Type_DeclContext *subrange_Type_Decl();
    Enum_Type_DeclContext *enum_Type_Decl();
    Array_Type_DeclContext *array_Type_Decl();
    Struct_Type_DeclContext *struct_Type_Decl();
    Str_Type_DeclContext *str_Type_Decl();
    Ref_Type_DeclContext *ref_Type_Decl();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Type_DeclContext* type_Decl();

  class  Simple_Type_DeclContext : public antlr4::ParserRuleContext {
  public:
    Simple_Type_DeclContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    Simple_Type_NameContext *simple_Type_Name();
    antlr4::tree::TerminalNode *Colon();
    Simple_Spec_InitContext *simple_Spec_Init();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Simple_Type_DeclContext* simple_Type_Decl();

  class  Nested_Simple_Type_DeclContext : public antlr4::ParserRuleContext {
  public:
    Nested_Simple_Type_DeclContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    Simple_Type_NameContext *simple_Type_Name();
    std::vector<NestedNameSpecifierContext *> nestedNameSpecifier();
    NestedNameSpecifierContext* nestedNameSpecifier(size_t i);

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Nested_Simple_Type_DeclContext* nested_Simple_Type_Decl();

  class  Simple_Spec_InitContext : public antlr4::ParserRuleContext {
  public:
    Simple_Spec_InitContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    Simple_SpecContext *simple_Spec();
    antlr4::tree::TerminalNode *Assign();
    Constant_ExprContext *constant_Expr();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Simple_Spec_InitContext* simple_Spec_Init();

  class  Simple_SpecContext : public antlr4::ParserRuleContext {
  public:
    Simple_SpecContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    Elem_Type_NameContext *elem_Type_Name();
    Nested_Simple_Type_DeclContext *nested_Simple_Type_Decl();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Simple_SpecContext* simple_Spec();

  class  Subrange_Type_DeclContext : public antlr4::ParserRuleContext {
  public:
    Subrange_Type_DeclContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    Subrange_Type_NameContext *subrange_Type_Name();
    antlr4::tree::TerminalNode *Colon();
    Subrange_Spec_InitContext *subrange_Spec_Init();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Subrange_Type_DeclContext* subrange_Type_Decl();

  class  Subrange_Spec_InitContext : public antlr4::ParserRuleContext {
  public:
    Subrange_Spec_InitContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    Subrange_SpecContext *subrange_Spec();
    antlr4::tree::TerminalNode *Assign();
    antlr4::tree::TerminalNode *Signed_Int();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Subrange_Spec_InitContext* subrange_Spec_Init();

  class  Subrange_SpecContext : public antlr4::ParserRuleContext {
  public:
    Subrange_SpecContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *Int_Type_Name();
    antlr4::tree::TerminalNode *LeftParen();
    SubrangeContext *subrange();
    antlr4::tree::TerminalNode *RightParen();
    Subrange_Type_NameContext *subrange_Type_Name();
    std::vector<NestedNameSpecifierContext *> nestedNameSpecifier();
    NestedNameSpecifierContext* nestedNameSpecifier(size_t i);

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Subrange_SpecContext* subrange_Spec();

  class  SubrangeContext : public antlr4::ParserRuleContext {
  public:
    SubrangeContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    std::vector<Constant_ExprContext *> constant_Expr();
    Constant_ExprContext* constant_Expr(size_t i);
    antlr4::tree::TerminalNode *RangeDot();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  SubrangeContext* subrange();

  class  Enum_Type_DeclContext : public antlr4::ParserRuleContext {
  public:
    Enum_Type_DeclContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    Enum_Type_NameContext *enum_Type_Name();
    antlr4::tree::TerminalNode *Colon();
    Enum_Spec_InitContext *enum_Spec_Init();
    Named_Spec_InitContext *named_Spec_Init();
    Elem_Type_NameContext *elem_Type_Name();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Enum_Type_DeclContext* enum_Type_Decl();

  class  Named_Spec_InitContext : public antlr4::ParserRuleContext {
  public:
    Named_Spec_InitContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *LeftParen();
    std::vector<Enum_Value_SpecContext *> enum_Value_Spec();
    Enum_Value_SpecContext* enum_Value_Spec(size_t i);
    antlr4::tree::TerminalNode *RightParen();
    std::vector<antlr4::tree::TerminalNode *> Comma();
    antlr4::tree::TerminalNode* Comma(size_t i);
    antlr4::tree::TerminalNode *Assign();
    Enum_ValueContext *enum_Value();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Named_Spec_InitContext* named_Spec_Init();

  class  Enum_Spec_InitContext : public antlr4::ParserRuleContext {
  public:
    Enum_Spec_InitContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    Enum_Type_NameContext *enum_Type_Name();
    antlr4::tree::TerminalNode *Assign();
    Enum_ValueContext *enum_Value();
    antlr4::tree::TerminalNode *LeftParen();
    std::vector<IdentifierContext *> identifier();
    IdentifierContext* identifier(size_t i);
    antlr4::tree::TerminalNode *RightParen();
    std::vector<NestedNameSpecifierContext *> nestedNameSpecifier();
    NestedNameSpecifierContext* nestedNameSpecifier(size_t i);
    std::vector<antlr4::tree::TerminalNode *> Comma();
    antlr4::tree::TerminalNode* Comma(size_t i);

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Enum_Spec_InitContext* enum_Spec_Init();

  class  Enum_Value_SpecContext : public antlr4::ParserRuleContext {
  public:
    Enum_Value_SpecContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    IdentifierContext *identifier();
    antlr4::tree::TerminalNode *Assign();
    Int_LiteralContext *int_Literal();
    Constant_ExprContext *constant_Expr();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Enum_Value_SpecContext* enum_Value_Spec();

  class  Enum_ValueContext : public antlr4::ParserRuleContext {
  public:
    Enum_ValueContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    IdentifierContext *identifier();
    Enum_Type_NameContext *enum_Type_Name();
    antlr4::tree::TerminalNode *TypeSign();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Enum_ValueContext* enum_Value();

  class  Array_Type_DeclContext : public antlr4::ParserRuleContext {
  public:
    Array_Type_DeclContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    Array_Type_NameContext *array_Type_Name();
    antlr4::tree::TerminalNode *Colon();
    Array_Spec_InitContext *array_Spec_Init();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Array_Type_DeclContext* array_Type_Decl();

  class  Array_Spec_InitContext : public antlr4::ParserRuleContext {
  public:
    Array_Spec_InitContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    Array_SpecContext *array_Spec();
    antlr4::tree::TerminalNode *Assign();
    Array_InitContext *array_Init();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Array_Spec_InitContext* array_Spec_Init();

  class  Array_SpecContext : public antlr4::ParserRuleContext {
  public:
    Array_SpecContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    Nested_Array_Type_NameContext *nested_Array_Type_Name();
    Direct_Array_Type_NameContext *direct_Array_Type_Name();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Array_SpecContext* array_Spec();

  class  Nested_Array_Type_NameContext : public antlr4::ParserRuleContext {
  public:
    Nested_Array_Type_NameContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    Array_Type_NameContext *array_Type_Name();
    std::vector<NestedNameSpecifierContext *> nestedNameSpecifier();
    NestedNameSpecifierContext* nestedNameSpecifier(size_t i);

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Nested_Array_Type_NameContext* nested_Array_Type_Name();

  class  Direct_Array_Type_NameContext : public antlr4::ParserRuleContext {
  public:
    Direct_Array_Type_NameContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *ARRAY();
    antlr4::tree::TerminalNode *LeftBracket();
    std::vector<SubrangeContext *> subrange();
    SubrangeContext* subrange(size_t i);
    antlr4::tree::TerminalNode *RightBracket();
    antlr4::tree::TerminalNode *OF();
    Data_Type_AccessContext *data_Type_Access();
    std::vector<antlr4::tree::TerminalNode *> Comma();
    antlr4::tree::TerminalNode* Comma(size_t i);

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Direct_Array_Type_NameContext* direct_Array_Type_Name();

  class  Array_InitContext : public antlr4::ParserRuleContext {
  public:
    Array_InitContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *LeftBracket();
    std::vector<Array_Elem_InitContext *> array_Elem_Init();
    Array_Elem_InitContext* array_Elem_Init(size_t i);
    antlr4::tree::TerminalNode *RightBracket();
    std::vector<antlr4::tree::TerminalNode *> Comma();
    antlr4::tree::TerminalNode* Comma(size_t i);

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Array_InitContext* array_Init();

  class  Array_Elem_InitContext : public antlr4::ParserRuleContext {
  public:
    Array_Elem_InitContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    Array_Elem_Init_ValueContext *array_Elem_Init_Value();
    Mult_Array_Elem_Init_ValueContext *mult_Array_Elem_Init_Value();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Array_Elem_InitContext* array_Elem_Init();

  class  Mult_Array_Elem_Init_ValueContext : public antlr4::ParserRuleContext {
  public:
    Mult_Array_Elem_Init_ValueContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *Unsigned_Int();
    antlr4::tree::TerminalNode *LeftParen();
    antlr4::tree::TerminalNode *RightParen();
    Array_Elem_Init_ValueContext *array_Elem_Init_Value();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Mult_Array_Elem_Init_ValueContext* mult_Array_Elem_Init_Value();

  class  Array_Elem_Init_ValueContext : public antlr4::ParserRuleContext {
  public:
    Array_Elem_Init_ValueContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    Constant_ExprContext *constant_Expr();
    Enum_ValueContext *enum_Value();
    Struct_InitContext *struct_Init();
    Array_InitContext *array_Init();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Array_Elem_Init_ValueContext* array_Elem_Init_Value();

  class  Struct_Type_DeclContext : public antlr4::ParserRuleContext {
  public:
    Struct_Type_DeclContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    Struct_Type_NameContext *struct_Type_Name();
    antlr4::tree::TerminalNode *Colon();
    Struct_SpecContext *struct_Spec();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Struct_Type_DeclContext* struct_Type_Decl();

  class  Nested_Struct_Type_DeclContext : public antlr4::ParserRuleContext {
  public:
    Nested_Struct_Type_DeclContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    Struct_Type_NameContext *struct_Type_Name();
    std::vector<NestedNameSpecifierContext *> nestedNameSpecifier();
    NestedNameSpecifierContext* nestedNameSpecifier(size_t i);

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Nested_Struct_Type_DeclContext* nested_Struct_Type_Decl();

  class  Struct_SpecContext : public antlr4::ParserRuleContext {
  public:
    Struct_SpecContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    Struct_DeclContext *struct_Decl();
    Struct_Spec_InitContext *struct_Spec_Init();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Struct_SpecContext* struct_Spec();

  class  Struct_Spec_InitContext : public antlr4::ParserRuleContext {
  public:
    Struct_Spec_InitContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    Nested_Struct_Type_DeclContext *nested_Struct_Type_Decl();
    antlr4::tree::TerminalNode *Assign();
    Struct_InitContext *struct_Init();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Struct_Spec_InitContext* struct_Spec_Init();

  class  Struct_DeclContext : public antlr4::ParserRuleContext {
  public:
    Struct_DeclContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *STRUCT();
    antlr4::tree::TerminalNode *END_STRUCT();
    antlr4::tree::TerminalNode *OVERLAP();
    std::vector<Struct_Elem_DeclContext *> struct_Elem_Decl();
    Struct_Elem_DeclContext* struct_Elem_Decl(size_t i);
    std::vector<antlr4::tree::TerminalNode *> Semi();
    antlr4::tree::TerminalNode* Semi(size_t i);

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Struct_DeclContext* struct_Decl();

  class  Struct_Elem_DeclContext : public antlr4::ParserRuleContext {
  public:
    Struct_Elem_DeclContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    Struct_Elem_NameContext *struct_Elem_Name();
    antlr4::tree::TerminalNode *Colon();
    Simple_Spec_InitContext *simple_Spec_Init();
    Subrange_Spec_InitContext *subrange_Spec_Init();
    Enum_Spec_InitContext *enum_Spec_Init();
    Array_Spec_InitContext *array_Spec_Init();
    Struct_Spec_InitContext *struct_Spec_Init();
    Located_AtContext *located_At();
    antlr4::tree::TerminalNode *Multibit_Part_Access();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Struct_Elem_DeclContext* struct_Elem_Decl();

  class  Struct_InitContext : public antlr4::ParserRuleContext {
  public:
    Struct_InitContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *LeftParen();
    std::vector<Struct_Elem_InitContext *> struct_Elem_Init();
    Struct_Elem_InitContext* struct_Elem_Init(size_t i);
    antlr4::tree::TerminalNode *RightParen();
    std::vector<antlr4::tree::TerminalNode *> Comma();
    antlr4::tree::TerminalNode* Comma(size_t i);

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Struct_InitContext* struct_Init();

  class  Struct_Elem_InitContext : public antlr4::ParserRuleContext {
  public:
    Struct_Elem_InitContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    Struct_Elem_NameContext *struct_Elem_Name();
    antlr4::tree::TerminalNode *Assign();
    Constant_ExprContext *constant_Expr();
    Enum_ValueContext *enum_Value();
    Array_InitContext *array_Init();
    Struct_InitContext *struct_Init();
    Ref_ValueContext *ref_Value();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Struct_Elem_InitContext* struct_Elem_Init();

  class  Str_Type_DeclContext : public antlr4::ParserRuleContext {
  public:
    Str_Type_DeclContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    std::vector<String_Type_NameContext *> string_Type_Name();
    String_Type_NameContext* string_Type_Name(size_t i);
    antlr4::tree::TerminalNode *Colon();
    antlr4::tree::TerminalNode *Assign();
    Char_StrContext *char_Str();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Str_Type_DeclContext* str_Type_Decl();

  class  Ref_Type_DeclContext : public antlr4::ParserRuleContext {
  public:
    Ref_Type_DeclContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    Ref_Type_NameContext *ref_Type_Name();
    antlr4::tree::TerminalNode *Colon();
    Ref_Spec_InitContext *ref_Spec_Init();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Ref_Type_DeclContext* ref_Type_Decl();

  class  Ref_Spec_InitContext : public antlr4::ParserRuleContext {
  public:
    Ref_Spec_InitContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    Ref_SpecContext *ref_Spec();
    antlr4::tree::TerminalNode *Assign();
    Ref_ValueContext *ref_Value();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Ref_Spec_InitContext* ref_Spec_Init();

  class  Ref_SpecContext : public antlr4::ParserRuleContext {
  public:
    Ref_SpecContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    Data_Type_AccessContext *data_Type_Access();
    std::vector<antlr4::tree::TerminalNode *> REF_TO();
    antlr4::tree::TerminalNode* REF_TO(size_t i);

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Ref_SpecContext* ref_Spec();

  class  Ref_Type_AccessContext : public antlr4::ParserRuleContext {
  public:
    Ref_Type_AccessContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    Ref_Type_NameContext *ref_Type_Name();
    std::vector<NestedNameSpecifierContext *> nestedNameSpecifier();
    NestedNameSpecifierContext* nestedNameSpecifier(size_t i);

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Ref_Type_AccessContext* ref_Type_Access();

  class  Ref_ValueContext : public antlr4::ParserRuleContext {
  public:
    Ref_ValueContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    Ref_AddrContext *ref_Addr();
    antlr4::tree::TerminalNode *Null();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Ref_ValueContext* ref_Value();

  class  Ref_AddrContext : public antlr4::ParserRuleContext {
  public:
    Ref_AddrContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *REF();
    antlr4::tree::TerminalNode *LeftParen();
    antlr4::tree::TerminalNode *RightParen();
    Symbolic_VariableContext *symbolic_Variable();
    FB_Instance_NameContext *fB_Instance_Name();
    Class_Instance_NameContext *class_Instance_Name();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Ref_AddrContext* ref_Addr();

  class  Ref_AssignContext : public antlr4::ParserRuleContext {
  public:
    Ref_AssignContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    std::vector<Ref_NameContext *> ref_Name();
    Ref_NameContext* ref_Name(size_t i);
    antlr4::tree::TerminalNode *Assign();
    Ref_DerefContext *ref_Deref();
    Ref_ValueContext *ref_Value();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Ref_AssignContext* ref_Assign();

  class  Ref_DerefContext : public antlr4::ParserRuleContext {
  public:
    Ref_DerefContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    Ref_NameContext *ref_Name();
    std::vector<antlr4::tree::TerminalNode *> Caret();
    antlr4::tree::TerminalNode* Caret(size_t i);

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Ref_DerefContext* ref_Deref();

  class  VariableContext : public antlr4::ParserRuleContext {
  public:
    VariableContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *Direct_Variable();
    Symbolic_VariableContext *symbolic_Variable();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  VariableContext* variable();

  class  Symbolic_VariableContext : public antlr4::ParserRuleContext {
  public:
    Symbolic_VariableContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    Var_AccessContext *var_Access();
    Multi_Elem_VarContext *multi_Elem_Var();
    antlr4::tree::TerminalNode *THIS();
    antlr4::tree::TerminalNode *Dot();
    std::vector<NestedNameSpecifierContext *> nestedNameSpecifier();
    NestedNameSpecifierContext* nestedNameSpecifier(size_t i);

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Symbolic_VariableContext* symbolic_Variable();

  class  Var_AccessContext : public antlr4::ParserRuleContext {
  public:
    Var_AccessContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    Variable_NameContext *variable_Name();
    Ref_DerefContext *ref_Deref();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Var_AccessContext* var_Access();

  class  Multi_Elem_VarContext : public antlr4::ParserRuleContext {
  public:
    Multi_Elem_VarContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    Var_AccessContext *var_Access();
    std::vector<Subscript_ListContext *> subscript_List();
    Subscript_ListContext* subscript_List(size_t i);
    std::vector<Struct_VariableContext *> struct_Variable();
    Struct_VariableContext* struct_Variable(size_t i);

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Multi_Elem_VarContext* multi_Elem_Var();

  class  Subscript_ListContext : public antlr4::ParserRuleContext {
  public:
    Subscript_ListContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *LeftBracket();
    std::vector<SubscriptContext *> subscript();
    SubscriptContext* subscript(size_t i);
    antlr4::tree::TerminalNode *RightBracket();
    std::vector<antlr4::tree::TerminalNode *> Comma();
    antlr4::tree::TerminalNode* Comma(size_t i);

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Subscript_ListContext* subscript_List();

  class  SubscriptContext : public antlr4::ParserRuleContext {
  public:
    SubscriptContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    ExpressionContext *expression();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  SubscriptContext* subscript();

  class  Struct_VariableContext : public antlr4::ParserRuleContext {
  public:
    Struct_VariableContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *Dot();
    Struct_Elem_SelectContext *struct_Elem_Select();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Struct_VariableContext* struct_Variable();

  class  Struct_Elem_SelectContext : public antlr4::ParserRuleContext {
  public:
    Struct_Elem_SelectContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    Var_AccessContext *var_Access();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Struct_Elem_SelectContext* struct_Elem_Select();

  class  Input_DeclsContext : public antlr4::ParserRuleContext {
  public:
    Input_DeclsContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *VAR_INPUT();
    antlr4::tree::TerminalNode *END_VAR();
    std::vector<Input_DeclContext *> input_Decl();
    Input_DeclContext* input_Decl(size_t i);
    std::vector<antlr4::tree::TerminalNode *> Semi();
    antlr4::tree::TerminalNode* Semi(size_t i);
    antlr4::tree::TerminalNode *RETAIN();
    antlr4::tree::TerminalNode *NON_RETAIN();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Input_DeclsContext* input_Decls();

  class  Input_DeclContext : public antlr4::ParserRuleContext {
  public:
    Input_DeclContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    Var_Decl_InitContext *var_Decl_Init();
    Edge_DeclContext *edge_Decl();
    Array_Conform_DeclContext *array_Conform_Decl();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Input_DeclContext* input_Decl();

  class  Var_Decl_InitContext : public antlr4::ParserRuleContext {
  public:
    Var_Decl_InitContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    Common_Var_Decl_InitContext *common_Var_Decl_Init();
    Interface_Spec_InitContext *interface_Spec_Init();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Var_Decl_InitContext* var_Decl_Init();

  class  Common_Var_Decl_InitContext : public antlr4::ParserRuleContext {
  public:
    Common_Var_Decl_InitContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    Variable_ListContext *variable_List();
    antlr4::tree::TerminalNode *Colon();
    Simple_Spec_InitContext *simple_Spec_Init();
    Ref_Spec_InitContext *ref_Spec_Init();
    Array_Spec_InitContext *array_Spec_Init();
    Struct_Spec_InitContext *struct_Spec_Init();
    FB_Spec_InitContext *fB_Spec_Init();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Common_Var_Decl_InitContext* common_Var_Decl_Init();

  class  Edge_DeclContext : public antlr4::ParserRuleContext {
  public:
    Edge_DeclContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    Variable_ListContext *variable_List();
    antlr4::tree::TerminalNode *Colon();
    antlr4::tree::TerminalNode *Bool_Type_Name();
    antlr4::tree::TerminalNode *R_EDGE();
    antlr4::tree::TerminalNode *F_EDGE();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Edge_DeclContext* edge_Decl();

  class  Ref_Var_DeclContext : public antlr4::ParserRuleContext {
  public:
    Ref_Var_DeclContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    Variable_ListContext *variable_List();
    antlr4::tree::TerminalNode *Colon();
    Ref_SpecContext *ref_Spec();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Ref_Var_DeclContext* ref_Var_Decl();

  class  Interface_Var_DeclContext : public antlr4::ParserRuleContext {
  public:
    Interface_Var_DeclContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    Variable_ListContext *variable_List();
    antlr4::tree::TerminalNode *Colon();
    Interface_Type_AccessContext *interface_Type_Access();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Interface_Var_DeclContext* interface_Var_Decl();

  class  Variable_ListContext : public antlr4::ParserRuleContext {
  public:
    Variable_ListContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    std::vector<Variable_NameContext *> variable_Name();
    Variable_NameContext* variable_Name(size_t i);
    std::vector<antlr4::tree::TerminalNode *> Comma();
    antlr4::tree::TerminalNode* Comma(size_t i);

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Variable_ListContext* variable_List();

  class  Array_ConformandContext : public antlr4::ParserRuleContext {
  public:
    Array_ConformandContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *ARRAY();
    antlr4::tree::TerminalNode *LeftBracket();
    std::vector<antlr4::tree::TerminalNode *> Star();
    antlr4::tree::TerminalNode* Star(size_t i);
    antlr4::tree::TerminalNode *RightBracket();
    antlr4::tree::TerminalNode *OF();
    Data_Type_AccessContext *data_Type_Access();
    std::vector<antlr4::tree::TerminalNode *> Comma();
    antlr4::tree::TerminalNode* Comma(size_t i);

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Array_ConformandContext* array_Conformand();

  class  Array_Conform_DeclContext : public antlr4::ParserRuleContext {
  public:
    Array_Conform_DeclContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    Variable_ListContext *variable_List();
    antlr4::tree::TerminalNode *Colon();
    Array_ConformandContext *array_Conformand();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Array_Conform_DeclContext* array_Conform_Decl();

  class  FB_Decl_No_InitContext : public antlr4::ParserRuleContext {
  public:
    FB_Decl_No_InitContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    Variable_ListContext *variable_List();
    antlr4::tree::TerminalNode *Colon();
    FB_Type_AccessContext *fB_Type_Access();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  FB_Decl_No_InitContext* fB_Decl_No_Init();

  class  FB_Spec_InitContext : public antlr4::ParserRuleContext {
  public:
    FB_Spec_InitContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    FB_Type_AccessContext *fB_Type_Access();
    antlr4::tree::TerminalNode *Assign();
    Struct_InitContext *struct_Init();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  FB_Spec_InitContext* fB_Spec_Init();

  class  FB_Instance_NameContext : public antlr4::ParserRuleContext {
  public:
    FB_Instance_NameContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    FB_NameContext *fB_Name();
    std::vector<NestedNameSpecifierContext *> nestedNameSpecifier();
    NestedNameSpecifierContext* nestedNameSpecifier(size_t i);
    std::vector<antlr4::tree::TerminalNode *> Caret();
    antlr4::tree::TerminalNode* Caret(size_t i);

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  FB_Instance_NameContext* fB_Instance_Name();

  class  Output_DeclsContext : public antlr4::ParserRuleContext {
  public:
    Output_DeclsContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *VAR_OUTPUT();
    antlr4::tree::TerminalNode *END_VAR();
    std::vector<Output_DeclContext *> output_Decl();
    Output_DeclContext* output_Decl(size_t i);
    std::vector<antlr4::tree::TerminalNode *> Semi();
    antlr4::tree::TerminalNode* Semi(size_t i);
    antlr4::tree::TerminalNode *RETAIN();
    antlr4::tree::TerminalNode *NON_RETAIN();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Output_DeclsContext* output_Decls();

  class  Output_DeclContext : public antlr4::ParserRuleContext {
  public:
    Output_DeclContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    Var_Decl_InitContext *var_Decl_Init();
    Array_Conform_DeclContext *array_Conform_Decl();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Output_DeclContext* output_Decl();

  class  In_Out_DeclsContext : public antlr4::ParserRuleContext {
  public:
    In_Out_DeclsContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *VAR_IN_OUT();
    antlr4::tree::TerminalNode *END_VAR();
    std::vector<In_Out_Var_DeclContext *> in_Out_Var_Decl();
    In_Out_Var_DeclContext* in_Out_Var_Decl(size_t i);
    std::vector<antlr4::tree::TerminalNode *> Semi();
    antlr4::tree::TerminalNode* Semi(size_t i);

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  In_Out_DeclsContext* in_Out_Decls();

  class  In_Out_Var_DeclContext : public antlr4::ParserRuleContext {
  public:
    In_Out_Var_DeclContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    Var_DeclContext *var_Decl();
    Array_Conform_DeclContext *array_Conform_Decl();
    FB_Decl_No_InitContext *fB_Decl_No_Init();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  In_Out_Var_DeclContext* in_Out_Var_Decl();

  class  Var_DeclContext : public antlr4::ParserRuleContext {
  public:
    Var_DeclContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    Variable_ListContext *variable_List();
    antlr4::tree::TerminalNode *Colon();
    Simple_SpecContext *simple_Spec();
    Str_Var_DeclContext *str_Var_Decl();
    Array_Var_DeclContext *array_Var_Decl();
    Struct_Var_DeclContext *struct_Var_Decl();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Var_DeclContext* var_Decl();

  class  Array_Var_DeclContext : public antlr4::ParserRuleContext {
  public:
    Array_Var_DeclContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    Variable_ListContext *variable_List();
    antlr4::tree::TerminalNode *Colon();
    Array_SpecContext *array_Spec();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Array_Var_DeclContext* array_Var_Decl();

  class  Struct_Var_DeclContext : public antlr4::ParserRuleContext {
  public:
    Struct_Var_DeclContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    Variable_ListContext *variable_List();
    antlr4::tree::TerminalNode *Colon();
    Struct_Type_AccessContext *struct_Type_Access();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Struct_Var_DeclContext* struct_Var_Decl();

  class  Var_DeclsContext : public antlr4::ParserRuleContext {
  public:
    Var_DeclsContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *VAR();
    antlr4::tree::TerminalNode *END_VAR();
    antlr4::tree::TerminalNode *CONSTANT();
    Access_SpecContext *access_Spec();
    std::vector<Var_Decl_InitContext *> var_Decl_Init();
    Var_Decl_InitContext* var_Decl_Init(size_t i);
    std::vector<antlr4::tree::TerminalNode *> Semi();
    antlr4::tree::TerminalNode* Semi(size_t i);

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Var_DeclsContext* var_Decls();

  class  Retain_Var_DeclsContext : public antlr4::ParserRuleContext {
  public:
    Retain_Var_DeclsContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *VAR();
    antlr4::tree::TerminalNode *RETAIN();
    antlr4::tree::TerminalNode *END_VAR();
    Access_SpecContext *access_Spec();
    std::vector<Var_Decl_InitContext *> var_Decl_Init();
    Var_Decl_InitContext* var_Decl_Init(size_t i);
    std::vector<antlr4::tree::TerminalNode *> Semi();
    antlr4::tree::TerminalNode* Semi(size_t i);

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Retain_Var_DeclsContext* retain_Var_Decls();

  class  Loc_Var_DeclsContext : public antlr4::ParserRuleContext {
  public:
    Loc_Var_DeclsContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *VAR();
    antlr4::tree::TerminalNode *END_VAR();
    std::vector<Loc_Var_DeclContext *> loc_Var_Decl();
    Loc_Var_DeclContext* loc_Var_Decl(size_t i);
    std::vector<antlr4::tree::TerminalNode *> Semi();
    antlr4::tree::TerminalNode* Semi(size_t i);
    antlr4::tree::TerminalNode *CONSTANT();
    antlr4::tree::TerminalNode *RETAIN();
    antlr4::tree::TerminalNode *NON_RETAIN();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Loc_Var_DeclsContext* loc_Var_Decls();

  class  Loc_Var_DeclContext : public antlr4::ParserRuleContext {
  public:
    Loc_Var_DeclContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    Located_AtContext *located_At();
    antlr4::tree::TerminalNode *Colon();
    Loc_Var_Spec_InitContext *loc_Var_Spec_Init();
    Variable_NameContext *variable_Name();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Loc_Var_DeclContext* loc_Var_Decl();

  class  Temp_Var_DeclsContext : public antlr4::ParserRuleContext {
  public:
    Temp_Var_DeclsContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *VAR_TEMP();
    antlr4::tree::TerminalNode *END_VAR();
    std::vector<antlr4::tree::TerminalNode *> Semi();
    antlr4::tree::TerminalNode* Semi(size_t i);
    std::vector<Var_DeclContext *> var_Decl();
    Var_DeclContext* var_Decl(size_t i);
    std::vector<Ref_Var_DeclContext *> ref_Var_Decl();
    Ref_Var_DeclContext* ref_Var_Decl(size_t i);
    std::vector<Interface_Var_DeclContext *> interface_Var_Decl();
    Interface_Var_DeclContext* interface_Var_Decl(size_t i);

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Temp_Var_DeclsContext* temp_Var_Decls();

  class  External_Var_DeclsContext : public antlr4::ParserRuleContext {
  public:
    External_Var_DeclsContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *VAR_EXTERNAL();
    antlr4::tree::TerminalNode *END_VAR();
    antlr4::tree::TerminalNode *CONSTANT();
    std::vector<External_DeclContext *> external_Decl();
    External_DeclContext* external_Decl(size_t i);
    std::vector<antlr4::tree::TerminalNode *> Semi();
    antlr4::tree::TerminalNode* Semi(size_t i);

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  External_Var_DeclsContext* external_Var_Decls();

  class  External_DeclContext : public antlr4::ParserRuleContext {
  public:
    External_DeclContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    Global_Var_NameContext *global_Var_Name();
    antlr4::tree::TerminalNode *Colon();
    Simple_SpecContext *simple_Spec();
    Array_SpecContext *array_Spec();
    Struct_Type_AccessContext *struct_Type_Access();
    FB_Type_AccessContext *fB_Type_Access();
    Ref_Type_AccessContext *ref_Type_Access();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  External_DeclContext* external_Decl();

  class  Global_Var_DeclsContext : public antlr4::ParserRuleContext {
  public:
    Global_Var_DeclsContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *VAR_GLOBAL();
    antlr4::tree::TerminalNode *END_VAR();
    std::vector<Global_Var_DeclContext *> global_Var_Decl();
    Global_Var_DeclContext* global_Var_Decl(size_t i);
    std::vector<antlr4::tree::TerminalNode *> Semi();
    antlr4::tree::TerminalNode* Semi(size_t i);
    antlr4::tree::TerminalNode *CONSTANT();
    antlr4::tree::TerminalNode *RETAIN();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Global_Var_DeclsContext* global_Var_Decls();

  class  Global_Var_DeclContext : public antlr4::ParserRuleContext {
  public:
    Global_Var_DeclContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    Global_Var_SpecContext *global_Var_Spec();
    antlr4::tree::TerminalNode *Colon();
    Loc_Var_Spec_InitContext *loc_Var_Spec_Init();
    FB_Type_AccessContext *fB_Type_Access();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Global_Var_DeclContext* global_Var_Decl();

  class  Global_Var_SpecContext : public antlr4::ParserRuleContext {
  public:
    Global_Var_SpecContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    std::vector<Global_Var_NameContext *> global_Var_Name();
    Global_Var_NameContext* global_Var_Name(size_t i);
    std::vector<antlr4::tree::TerminalNode *> Comma();
    antlr4::tree::TerminalNode* Comma(size_t i);
    Located_AtContext *located_At();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Global_Var_SpecContext* global_Var_Spec();

  class  Loc_Var_Spec_InitContext : public antlr4::ParserRuleContext {
  public:
    Loc_Var_Spec_InitContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    Simple_Spec_InitContext *simple_Spec_Init();
    Array_Spec_InitContext *array_Spec_Init();
    Struct_Spec_InitContext *struct_Spec_Init();
    S_Byte_Str_SpecContext *s_Byte_Str_Spec();
    D_Byte_Str_SpecContext *d_Byte_Str_Spec();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Loc_Var_Spec_InitContext* loc_Var_Spec_Init();

  class  Located_AtContext : public antlr4::ParserRuleContext {
  public:
    Located_AtContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *AT();
    antlr4::tree::TerminalNode *Direct_Variable();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Located_AtContext* located_At();

  class  Str_Var_DeclContext : public antlr4::ParserRuleContext {
  public:
    Str_Var_DeclContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    S_Byte_Str_Var_DeclContext *s_Byte_Str_Var_Decl();
    D_Byte_Str_Var_DeclContext *d_Byte_Str_Var_Decl();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Str_Var_DeclContext* str_Var_Decl();

  class  S_Byte_Str_Var_DeclContext : public antlr4::ParserRuleContext {
  public:
    S_Byte_Str_Var_DeclContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    Variable_ListContext *variable_List();
    antlr4::tree::TerminalNode *Colon();
    S_Byte_Str_SpecContext *s_Byte_Str_Spec();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  S_Byte_Str_Var_DeclContext* s_Byte_Str_Var_Decl();

  class  S_Byte_Str_SpecContext : public antlr4::ParserRuleContext {
  public:
    S_Byte_Str_SpecContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *SString_Type_Name();
    antlr4::tree::TerminalNode *Assign();
    antlr4::tree::TerminalNode *S_Byte_Char_Str();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  S_Byte_Str_SpecContext* s_Byte_Str_Spec();

  class  D_Byte_Str_Var_DeclContext : public antlr4::ParserRuleContext {
  public:
    D_Byte_Str_Var_DeclContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    Variable_ListContext *variable_List();
    antlr4::tree::TerminalNode *Colon();
    D_Byte_Str_SpecContext *d_Byte_Str_Spec();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  D_Byte_Str_Var_DeclContext* d_Byte_Str_Var_Decl();

  class  D_Byte_Str_SpecContext : public antlr4::ParserRuleContext {
  public:
    D_Byte_Str_SpecContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *WString_Type_Name();
    antlr4::tree::TerminalNode *Assign();
    antlr4::tree::TerminalNode *D_Byte_Char_Str();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  D_Byte_Str_SpecContext* d_Byte_Str_Spec();

  class  Loc_Partly_Var_DeclContext : public antlr4::ParserRuleContext {
  public:
    Loc_Partly_Var_DeclContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *VAR();
    antlr4::tree::TerminalNode *END_VAR();
    std::vector<Loc_Partly_VarContext *> loc_Partly_Var();
    Loc_Partly_VarContext* loc_Partly_Var(size_t i);
    antlr4::tree::TerminalNode *RETAIN();
    antlr4::tree::TerminalNode *NON_RETAIN();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Loc_Partly_Var_DeclContext* loc_Partly_Var_Decl();

  class  Loc_Partly_VarContext : public antlr4::ParserRuleContext {
  public:
    Loc_Partly_VarContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    Variable_NameContext *variable_Name();
    antlr4::tree::TerminalNode *AT();
    antlr4::tree::TerminalNode *Var_Location();
    antlr4::tree::TerminalNode *Colon();
    Var_SpecContext *var_Spec();
    antlr4::tree::TerminalNode *Semi();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Loc_Partly_VarContext* loc_Partly_Var();

  class  Var_SpecContext : public antlr4::ParserRuleContext {
  public:
    Var_SpecContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    Simple_SpecContext *simple_Spec();
    Array_SpecContext *array_Spec();
    Struct_Type_AccessContext *struct_Type_Access();
    antlr4::tree::TerminalNode *SString_Type_Name();
    antlr4::tree::TerminalNode *WString_Type_Name();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Var_SpecContext* var_Spec();

  class  Func_NameContext : public antlr4::ParserRuleContext {
  public:
    Func_NameContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *Std_Func_Name();
    Derived_Func_NameContext *derived_Func_Name();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Func_NameContext* func_Name();

  class  Func_AccessContext : public antlr4::ParserRuleContext {
  public:
    Func_AccessContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    Func_NameContext *func_Name();
    std::vector<NestedNameSpecifierContext *> nestedNameSpecifier();
    NestedNameSpecifierContext* nestedNameSpecifier(size_t i);

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Func_AccessContext* func_Access();

  class  Func_DeclContext : public antlr4::ParserRuleContext {
  public:
    Func_DeclContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *FUNCTION();
    Derived_Func_NameContext *derived_Func_Name();
    Func_BodyContext *func_Body();
    antlr4::tree::TerminalNode *END_FUNCTION();
    antlr4::tree::TerminalNode *Colon();
    Data_Type_AccessContext *data_Type_Access();
    std::vector<Using_DirectiveContext *> using_Directive();
    Using_DirectiveContext* using_Directive(size_t i);
    std::vector<IO_Var_DeclsContext *> iO_Var_Decls();
    IO_Var_DeclsContext* iO_Var_Decls(size_t i);
    std::vector<Func_Var_DeclsContext *> func_Var_Decls();
    Func_Var_DeclsContext* func_Var_Decls(size_t i);
    std::vector<Temp_Var_DeclsContext *> temp_Var_Decls();
    Temp_Var_DeclsContext* temp_Var_Decls(size_t i);

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Func_DeclContext* func_Decl();

  class  IO_Var_DeclsContext : public antlr4::ParserRuleContext {
  public:
    IO_Var_DeclsContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    Input_DeclsContext *input_Decls();
    Output_DeclsContext *output_Decls();
    In_Out_DeclsContext *in_Out_Decls();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  IO_Var_DeclsContext* iO_Var_Decls();

  class  Func_Var_DeclsContext : public antlr4::ParserRuleContext {
  public:
    Func_Var_DeclsContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    External_Var_DeclsContext *external_Var_Decls();
    Var_DeclsContext *var_Decls();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Func_Var_DeclsContext* func_Var_Decls();

  class  Func_BodyContext : public antlr4::ParserRuleContext {
  public:
    Func_BodyContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    Stmt_ListContext *stmt_List();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Func_BodyContext* func_Body();

  class  FB_Type_NameContext : public antlr4::ParserRuleContext {
  public:
    FB_Type_NameContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *Std_FB_Name();
    Derived_FB_NameContext *derived_FB_Name();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  FB_Type_NameContext* fB_Type_Name();

  class  FB_Type_AccessContext : public antlr4::ParserRuleContext {
  public:
    FB_Type_AccessContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    FB_Type_NameContext *fB_Type_Name();
    std::vector<NestedNameSpecifierContext *> nestedNameSpecifier();
    NestedNameSpecifierContext* nestedNameSpecifier(size_t i);

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  FB_Type_AccessContext* fB_Type_Access();

  class  FB_DeclContext : public antlr4::ParserRuleContext {
  public:
    FB_DeclContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *FUNCTION_BLOCK();
    Derived_FB_NameContext *derived_FB_Name();
    FB_BodyContext *fB_Body();
    antlr4::tree::TerminalNode *END_FUNCTION_BLOCK();
    std::vector<Using_DirectiveContext *> using_Directive();
    Using_DirectiveContext* using_Directive(size_t i);
    antlr4::tree::TerminalNode *EXTENDS();
    antlr4::tree::TerminalNode *IMPLEMENTS();
    Interface_Name_ListContext *interface_Name_List();
    std::vector<FB_IO_Var_DeclsContext *> fB_IO_Var_Decls();
    FB_IO_Var_DeclsContext* fB_IO_Var_Decls(size_t i);
    std::vector<Func_Var_DeclsContext *> func_Var_Decls();
    Func_Var_DeclsContext* func_Var_Decls(size_t i);
    std::vector<Temp_Var_DeclsContext *> temp_Var_Decls();
    Temp_Var_DeclsContext* temp_Var_Decls(size_t i);
    std::vector<Other_Var_DeclsContext *> other_Var_Decls();
    Other_Var_DeclsContext* other_Var_Decls(size_t i);
    std::vector<Method_DeclContext *> method_Decl();
    Method_DeclContext* method_Decl(size_t i);
    antlr4::tree::TerminalNode *FINAL();
    antlr4::tree::TerminalNode *ABSTRACT();
    FB_Type_AccessContext *fB_Type_Access();
    Class_Type_AccessContext *class_Type_Access();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  FB_DeclContext* fB_Decl();

  class  FB_IO_Var_DeclsContext : public antlr4::ParserRuleContext {
  public:
    FB_IO_Var_DeclsContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    FB_Input_DeclsContext *fB_Input_Decls();
    FB_Output_DeclsContext *fB_Output_Decls();
    In_Out_DeclsContext *in_Out_Decls();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  FB_IO_Var_DeclsContext* fB_IO_Var_Decls();

  class  FB_Input_DeclsContext : public antlr4::ParserRuleContext {
  public:
    FB_Input_DeclsContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *VAR_INPUT();
    antlr4::tree::TerminalNode *END_VAR();
    std::vector<FB_Input_DeclContext *> fB_Input_Decl();
    FB_Input_DeclContext* fB_Input_Decl(size_t i);
    std::vector<antlr4::tree::TerminalNode *> Semi();
    antlr4::tree::TerminalNode* Semi(size_t i);
    antlr4::tree::TerminalNode *RETAIN();
    antlr4::tree::TerminalNode *NON_RETAIN();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  FB_Input_DeclsContext* fB_Input_Decls();

  class  FB_Input_DeclContext : public antlr4::ParserRuleContext {
  public:
    FB_Input_DeclContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    Var_Decl_InitContext *var_Decl_Init();
    Edge_DeclContext *edge_Decl();
    Array_Conform_DeclContext *array_Conform_Decl();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  FB_Input_DeclContext* fB_Input_Decl();

  class  FB_Output_DeclsContext : public antlr4::ParserRuleContext {
  public:
    FB_Output_DeclsContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *VAR_OUTPUT();
    antlr4::tree::TerminalNode *END_VAR();
    std::vector<FB_Output_DeclContext *> fB_Output_Decl();
    FB_Output_DeclContext* fB_Output_Decl(size_t i);
    std::vector<antlr4::tree::TerminalNode *> Semi();
    antlr4::tree::TerminalNode* Semi(size_t i);
    antlr4::tree::TerminalNode *RETAIN();
    antlr4::tree::TerminalNode *NON_RETAIN();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  FB_Output_DeclsContext* fB_Output_Decls();

  class  FB_Output_DeclContext : public antlr4::ParserRuleContext {
  public:
    FB_Output_DeclContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    Var_Decl_InitContext *var_Decl_Init();
    Array_Conform_DeclContext *array_Conform_Decl();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  FB_Output_DeclContext* fB_Output_Decl();

  class  Other_Var_DeclsContext : public antlr4::ParserRuleContext {
  public:
    Other_Var_DeclsContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    Retain_Var_DeclsContext *retain_Var_Decls();
    No_Retain_Var_DeclsContext *no_Retain_Var_Decls();
    Loc_Partly_Var_DeclContext *loc_Partly_Var_Decl();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Other_Var_DeclsContext* other_Var_Decls();

  class  No_Retain_Var_DeclsContext : public antlr4::ParserRuleContext {
  public:
    No_Retain_Var_DeclsContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *VAR();
    antlr4::tree::TerminalNode *NON_RETAIN();
    antlr4::tree::TerminalNode *END_VAR();
    Access_SpecContext *access_Spec();
    std::vector<Var_Decl_InitContext *> var_Decl_Init();
    Var_Decl_InitContext* var_Decl_Init(size_t i);
    std::vector<antlr4::tree::TerminalNode *> Semi();
    antlr4::tree::TerminalNode* Semi(size_t i);

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  No_Retain_Var_DeclsContext* no_Retain_Var_Decls();

  class  FB_BodyContext : public antlr4::ParserRuleContext {
  public:
    FB_BodyContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    Stmt_ListContext *stmt_List();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  FB_BodyContext* fB_Body();

  class  Method_DeclContext : public antlr4::ParserRuleContext {
  public:
    Method_DeclContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *METHOD();
    Access_SpecContext *access_Spec();
    Method_NameContext *method_Name();
    Func_BodyContext *func_Body();
    antlr4::tree::TerminalNode *END_METHOD();
    antlr4::tree::TerminalNode *OVERRIDE();
    antlr4::tree::TerminalNode *Colon();
    Data_Type_AccessContext *data_Type_Access();
    std::vector<IO_Var_DeclsContext *> iO_Var_Decls();
    IO_Var_DeclsContext* iO_Var_Decls(size_t i);
    std::vector<Func_Var_DeclsContext *> func_Var_Decls();
    Func_Var_DeclsContext* func_Var_Decls(size_t i);
    std::vector<Temp_Var_DeclsContext *> temp_Var_Decls();
    Temp_Var_DeclsContext* temp_Var_Decls(size_t i);
    antlr4::tree::TerminalNode *FINAL();
    antlr4::tree::TerminalNode *ABSTRACT();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Method_DeclContext* method_Decl();

  class  Access_SpecContext : public antlr4::ParserRuleContext {
  public:
    Access_SpecContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *PUBLIC();
    antlr4::tree::TerminalNode *PROTECTED();
    antlr4::tree::TerminalNode *PRIVATE();
    antlr4::tree::TerminalNode *INTERNAL();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Access_SpecContext* access_Spec();

  class  Class_DeclContext : public antlr4::ParserRuleContext {
  public:
    Class_DeclContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *CLASS();
    Class_Type_NameContext *class_Type_Name();
    antlr4::tree::TerminalNode *END_CLASS();
    std::vector<Using_DirectiveContext *> using_Directive();
    Using_DirectiveContext* using_Directive(size_t i);
    antlr4::tree::TerminalNode *EXTENDS();
    Class_Type_AccessContext *class_Type_Access();
    antlr4::tree::TerminalNode *IMPLEMENTS();
    Interface_Name_ListContext *interface_Name_List();
    std::vector<Func_Var_DeclsContext *> func_Var_Decls();
    Func_Var_DeclsContext* func_Var_Decls(size_t i);
    std::vector<Other_Var_DeclsContext *> other_Var_Decls();
    Other_Var_DeclsContext* other_Var_Decls(size_t i);
    std::vector<Method_DeclContext *> method_Decl();
    Method_DeclContext* method_Decl(size_t i);
    antlr4::tree::TerminalNode *FINAL();
    antlr4::tree::TerminalNode *ABSTRACT();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Class_DeclContext* class_Decl();

  class  Class_Type_AccessContext : public antlr4::ParserRuleContext {
  public:
    Class_Type_AccessContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    Class_Type_NameContext *class_Type_Name();
    std::vector<NestedNameSpecifierContext *> nestedNameSpecifier();
    NestedNameSpecifierContext* nestedNameSpecifier(size_t i);

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Class_Type_AccessContext* class_Type_Access();

  class  Class_Instance_NameContext : public antlr4::ParserRuleContext {
  public:
    Class_Instance_NameContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    Class_NameContext *class_Name();
    std::vector<NestedNameSpecifierContext *> nestedNameSpecifier();
    NestedNameSpecifierContext* nestedNameSpecifier(size_t i);
    std::vector<antlr4::tree::TerminalNode *> Caret();
    antlr4::tree::TerminalNode* Caret(size_t i);

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Class_Instance_NameContext* class_Instance_Name();

  class  Interface_DeclContext : public antlr4::ParserRuleContext {
  public:
    Interface_DeclContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *INTERFACE();
    Interface_Type_NameContext *interface_Type_Name();
    antlr4::tree::TerminalNode *END_INTERFACE();
    std::vector<Using_DirectiveContext *> using_Directive();
    Using_DirectiveContext* using_Directive(size_t i);
    antlr4::tree::TerminalNode *EXTENDS();
    Interface_Name_ListContext *interface_Name_List();
    std::vector<Method_PrototypeContext *> method_Prototype();
    Method_PrototypeContext* method_Prototype(size_t i);

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Interface_DeclContext* interface_Decl();

  class  Method_PrototypeContext : public antlr4::ParserRuleContext {
  public:
    Method_PrototypeContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *METHOD();
    Method_NameContext *method_Name();
    antlr4::tree::TerminalNode *END_METHOD();
    antlr4::tree::TerminalNode *Colon();
    Data_Type_AccessContext *data_Type_Access();
    std::vector<IO_Var_DeclsContext *> iO_Var_Decls();
    IO_Var_DeclsContext* iO_Var_Decls(size_t i);

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Method_PrototypeContext* method_Prototype();

  class  Interface_Spec_InitContext : public antlr4::ParserRuleContext {
  public:
    Interface_Spec_InitContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    Variable_ListContext *variable_List();
    antlr4::tree::TerminalNode *Assign();
    Interface_ValueContext *interface_Value();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Interface_Spec_InitContext* interface_Spec_Init();

  class  Interface_ValueContext : public antlr4::ParserRuleContext {
  public:
    Interface_ValueContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    Symbolic_VariableContext *symbolic_Variable();
    FB_Instance_NameContext *fB_Instance_Name();
    Class_Instance_NameContext *class_Instance_Name();
    antlr4::tree::TerminalNode *Null();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Interface_ValueContext* interface_Value();

  class  Interface_Name_ListContext : public antlr4::ParserRuleContext {
  public:
    Interface_Name_ListContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    std::vector<Interface_Type_AccessContext *> interface_Type_Access();
    Interface_Type_AccessContext* interface_Type_Access(size_t i);
    std::vector<antlr4::tree::TerminalNode *> Comma();
    antlr4::tree::TerminalNode* Comma(size_t i);

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Interface_Name_ListContext* interface_Name_List();

  class  Interface_Type_AccessContext : public antlr4::ParserRuleContext {
  public:
    Interface_Type_AccessContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    Interface_Type_NameContext *interface_Type_Name();
    std::vector<NestedNameSpecifierContext *> nestedNameSpecifier();
    NestedNameSpecifierContext* nestedNameSpecifier(size_t i);

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Interface_Type_AccessContext* interface_Type_Access();

  class  Prog_DeclContext : public antlr4::ParserRuleContext {
  public:
    Prog_DeclContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *PROGRAM();
    Prog_Type_NameContext *prog_Type_Name();
    FB_BodyContext *fB_Body();
    antlr4::tree::TerminalNode *END_PROGRAM();
    std::vector<IO_Var_DeclsContext *> iO_Var_Decls();
    IO_Var_DeclsContext* iO_Var_Decls(size_t i);
    std::vector<Func_Var_DeclsContext *> func_Var_Decls();
    Func_Var_DeclsContext* func_Var_Decls(size_t i);
    std::vector<Temp_Var_DeclsContext *> temp_Var_Decls();
    Temp_Var_DeclsContext* temp_Var_Decls(size_t i);
    std::vector<Other_Var_DeclsContext *> other_Var_Decls();
    Other_Var_DeclsContext* other_Var_Decls(size_t i);
    std::vector<Loc_Var_DeclsContext *> loc_Var_Decls();
    Loc_Var_DeclsContext* loc_Var_Decls(size_t i);
    std::vector<Prog_Access_DeclsContext *> prog_Access_Decls();
    Prog_Access_DeclsContext* prog_Access_Decls(size_t i);

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Prog_DeclContext* prog_Decl();

  class  Prog_Type_AccessContext : public antlr4::ParserRuleContext {
  public:
    Prog_Type_AccessContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    Prog_Type_NameContext *prog_Type_Name();
    std::vector<NestedNameSpecifierContext *> nestedNameSpecifier();
    NestedNameSpecifierContext* nestedNameSpecifier(size_t i);

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Prog_Type_AccessContext* prog_Type_Access();

  class  Prog_Access_DeclsContext : public antlr4::ParserRuleContext {
  public:
    Prog_Access_DeclsContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *VAR_ACCESS();
    antlr4::tree::TerminalNode *END_VAR();
    std::vector<Prog_Access_DeclContext *> prog_Access_Decl();
    Prog_Access_DeclContext* prog_Access_Decl(size_t i);
    std::vector<antlr4::tree::TerminalNode *> Semi();
    antlr4::tree::TerminalNode* Semi(size_t i);

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Prog_Access_DeclsContext* prog_Access_Decls();

  class  Prog_Access_DeclContext : public antlr4::ParserRuleContext {
  public:
    Prog_Access_DeclContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    Access_NameContext *access_Name();
    std::vector<antlr4::tree::TerminalNode *> Colon();
    antlr4::tree::TerminalNode* Colon(size_t i);
    Symbolic_VariableContext *symbolic_Variable();
    Data_Type_AccessContext *data_Type_Access();
    antlr4::tree::TerminalNode *Multibit_Part_Access();
    antlr4::tree::TerminalNode *Access_Direction();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Prog_Access_DeclContext* prog_Access_Decl();

  class  SFCContext : public antlr4::ParserRuleContext {
  public:
    SFCContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    std::vector<Sfc_NetworkContext *> sfc_Network();
    Sfc_NetworkContext* sfc_Network(size_t i);

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  SFCContext* sFC();

  class  Sfc_NetworkContext : public antlr4::ParserRuleContext {
  public:
    Sfc_NetworkContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    Initial_StepContext *initial_Step();
    std::vector<StepContext *> step();
    StepContext* step(size_t i);
    std::vector<TransitionContext *> transition();
    TransitionContext* transition(size_t i);
    std::vector<ActionContext *> action();
    ActionContext* action(size_t i);

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Sfc_NetworkContext* sfc_Network();

  class  Initial_StepContext : public antlr4::ParserRuleContext {
  public:
    Initial_StepContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *INITIAL_STEP();
    Step_NameContext *step_Name();
    antlr4::tree::TerminalNode *Colon();
    antlr4::tree::TerminalNode *END_STEP();
    std::vector<Action_AssociationContext *> action_Association();
    Action_AssociationContext* action_Association(size_t i);
    std::vector<antlr4::tree::TerminalNode *> Semi();
    antlr4::tree::TerminalNode* Semi(size_t i);

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Initial_StepContext* initial_Step();

  class  StepContext : public antlr4::ParserRuleContext {
  public:
    StepContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *STEP();
    Step_NameContext *step_Name();
    antlr4::tree::TerminalNode *Colon();
    antlr4::tree::TerminalNode *END_STEP();
    std::vector<Action_AssociationContext *> action_Association();
    Action_AssociationContext* action_Association(size_t i);
    std::vector<antlr4::tree::TerminalNode *> Semi();
    antlr4::tree::TerminalNode* Semi(size_t i);

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  StepContext* step();

  class  Action_AssociationContext : public antlr4::ParserRuleContext {
  public:
    Action_AssociationContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    Action_NameContext *action_Name();
    antlr4::tree::TerminalNode *LeftParen();
    antlr4::tree::TerminalNode *RightParen();
    Action_QualifierContext *action_Qualifier();
    std::vector<antlr4::tree::TerminalNode *> Comma();
    antlr4::tree::TerminalNode* Comma(size_t i);
    std::vector<Indicator_NameContext *> indicator_Name();
    Indicator_NameContext* indicator_Name(size_t i);

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Action_AssociationContext* action_Association();

  class  Action_QualifierContext : public antlr4::ParserRuleContext {
  public:
    Action_QualifierContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *ACTION_QUALIFIER();
    antlr4::tree::TerminalNode *ACTION_TIME_QUALIFIER();
    antlr4::tree::TerminalNode *Comma();
    Action_TimeContext *action_Time();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Action_QualifierContext* action_Qualifier();

  class  Action_TimeContext : public antlr4::ParserRuleContext {
  public:
    Action_TimeContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *Duration();
    Variable_NameContext *variable_Name();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Action_TimeContext* action_Time();

  class  TransitionContext : public antlr4::ParserRuleContext {
  public:
    TransitionContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *TRANSITION();
    antlr4::tree::TerminalNode *FROM();
    std::vector<StepsContext *> steps();
    StepsContext* steps(size_t i);
    antlr4::tree::TerminalNode *TO();
    antlr4::tree::TerminalNode *Colon();
    Transition_CondContext *transition_Cond();
    antlr4::tree::TerminalNode *END_TRANSITION();
    Transition_NameContext *transition_Name();
    antlr4::tree::TerminalNode *LeftParen();
    antlr4::tree::TerminalNode *PRIORITY();
    antlr4::tree::TerminalNode *Assign();
    antlr4::tree::TerminalNode *Unsigned_Int();
    antlr4::tree::TerminalNode *RightParen();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  TransitionContext* transition();

  class  StepsContext : public antlr4::ParserRuleContext {
  public:
    StepsContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    std::vector<Step_NameContext *> step_Name();
    Step_NameContext* step_Name(size_t i);
    antlr4::tree::TerminalNode *LeftParen();
    antlr4::tree::TerminalNode *RightParen();
    std::vector<antlr4::tree::TerminalNode *> Comma();
    antlr4::tree::TerminalNode* Comma(size_t i);

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  StepsContext* steps();

  class  Transition_CondContext : public antlr4::ParserRuleContext {
  public:
    Transition_CondContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *Assign();
    ExpressionContext *expression();
    antlr4::tree::TerminalNode *Semi();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Transition_CondContext* transition_Cond();

  class  ActionContext : public antlr4::ParserRuleContext {
  public:
    ActionContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *ACTION();
    Action_NameContext *action_Name();
    antlr4::tree::TerminalNode *Colon();
    FB_BodyContext *fB_Body();
    antlr4::tree::TerminalNode *END_ACTION();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  ActionContext* action();

  class  Config_DeclContext : public antlr4::ParserRuleContext {
  public:
    Config_DeclContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *CONFIGURATION();
    Config_NameContext *config_Name();
    antlr4::tree::TerminalNode *END_CONFIGURATION();
    Single_Resource_DeclContext *single_Resource_Decl();
    Global_Var_DeclsContext *global_Var_Decls();
    Access_DeclsContext *access_Decls();
    Config_InitContext *config_Init();
    std::vector<Resource_DeclContext *> resource_Decl();
    Resource_DeclContext* resource_Decl(size_t i);

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Config_DeclContext* config_Decl();

  class  Resource_DeclContext : public antlr4::ParserRuleContext {
  public:
    Resource_DeclContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *RESOURCE();
    Resource_NameContext *resource_Name();
    antlr4::tree::TerminalNode *ON();
    Resource_Type_NameContext *resource_Type_Name();
    Single_Resource_DeclContext *single_Resource_Decl();
    antlr4::tree::TerminalNode *END_RESOURCE();
    Global_Var_DeclsContext *global_Var_Decls();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Resource_DeclContext* resource_Decl();

  class  Single_Resource_DeclContext : public antlr4::ParserRuleContext {
  public:
    Single_Resource_DeclContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    std::vector<Task_ConfigContext *> task_Config();
    Task_ConfigContext* task_Config(size_t i);
    std::vector<antlr4::tree::TerminalNode *> Semi();
    antlr4::tree::TerminalNode* Semi(size_t i);
    std::vector<Prog_ConfigContext *> prog_Config();
    Prog_ConfigContext* prog_Config(size_t i);

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Single_Resource_DeclContext* single_Resource_Decl();

  class  Access_DeclsContext : public antlr4::ParserRuleContext {
  public:
    Access_DeclsContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *VAR_ACCESS();
    antlr4::tree::TerminalNode *END_VAR();
    std::vector<Access_DeclContext *> access_Decl();
    Access_DeclContext* access_Decl(size_t i);
    std::vector<antlr4::tree::TerminalNode *> Semi();
    antlr4::tree::TerminalNode* Semi(size_t i);

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Access_DeclsContext* access_Decls();

  class  Access_DeclContext : public antlr4::ParserRuleContext {
  public:
    Access_DeclContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    Access_NameContext *access_Name();
    std::vector<antlr4::tree::TerminalNode *> Colon();
    antlr4::tree::TerminalNode* Colon(size_t i);
    Access_PathContext *access_Path();
    Data_Type_AccessContext *data_Type_Access();
    antlr4::tree::TerminalNode *Access_Direction();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Access_DeclContext* access_Decl();

  class  Access_PathContext : public antlr4::ParserRuleContext {
  public:
    Access_PathContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *Direct_Variable();
    Resource_NameContext *resource_Name();
    std::vector<antlr4::tree::TerminalNode *> Dot();
    antlr4::tree::TerminalNode* Dot(size_t i);
    Symbolic_VariableContext *symbolic_Variable();
    Prog_NameContext *prog_Name();
    std::vector<FB_Instance_NameContext *> fB_Instance_Name();
    FB_Instance_NameContext* fB_Instance_Name(size_t i);
    std::vector<Class_Instance_NameContext *> class_Instance_Name();
    Class_Instance_NameContext* class_Instance_Name(size_t i);

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Access_PathContext* access_Path();

  class  Global_Var_AccessContext : public antlr4::ParserRuleContext {
  public:
    Global_Var_AccessContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    Global_Var_NameContext *global_Var_Name();
    Resource_NameContext *resource_Name();
    std::vector<antlr4::tree::TerminalNode *> Dot();
    antlr4::tree::TerminalNode* Dot(size_t i);
    Struct_Elem_NameContext *struct_Elem_Name();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Global_Var_AccessContext* global_Var_Access();

  class  Prog_Output_AccessContext : public antlr4::ParserRuleContext {
  public:
    Prog_Output_AccessContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    Prog_NameContext *prog_Name();
    antlr4::tree::TerminalNode *Dot();
    Symbolic_VariableContext *symbolic_Variable();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Prog_Output_AccessContext* prog_Output_Access();

  class  Task_ConfigContext : public antlr4::ParserRuleContext {
  public:
    Task_ConfigContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *TASK();
    Task_NameContext *task_Name();
    Task_InitContext *task_Init();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Task_ConfigContext* task_Config();

  class  Task_InitContext : public antlr4::ParserRuleContext {
  public:
    Task_InitContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *LeftParen();
    antlr4::tree::TerminalNode *PRIORITY();
    std::vector<antlr4::tree::TerminalNode *> Assign();
    antlr4::tree::TerminalNode* Assign(size_t i);
    antlr4::tree::TerminalNode *Unsigned_Int();
    antlr4::tree::TerminalNode *RightParen();
    antlr4::tree::TerminalNode *SINGLE();
    std::vector<Data_SourceContext *> data_Source();
    Data_SourceContext* data_Source(size_t i);
    std::vector<antlr4::tree::TerminalNode *> Comma();
    antlr4::tree::TerminalNode* Comma(size_t i);
    antlr4::tree::TerminalNode *INTERVAL();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Task_InitContext* task_Init();

  class  Data_SourceContext : public antlr4::ParserRuleContext {
  public:
    Data_SourceContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    ConstantContext *constant();
    Global_Var_AccessContext *global_Var_Access();
    Prog_Output_AccessContext *prog_Output_Access();
    antlr4::tree::TerminalNode *Direct_Variable();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Data_SourceContext* data_Source();

  class  Prog_ConfigContext : public antlr4::ParserRuleContext {
  public:
    Prog_ConfigContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *PROGRAM();
    Prog_NameContext *prog_Name();
    antlr4::tree::TerminalNode *Colon();
    Prog_Type_AccessContext *prog_Type_Access();
    antlr4::tree::TerminalNode *WITH();
    Task_NameContext *task_Name();
    antlr4::tree::TerminalNode *LeftParen();
    Prog_Conf_ElemsContext *prog_Conf_Elems();
    antlr4::tree::TerminalNode *RightParen();
    antlr4::tree::TerminalNode *RETAIN();
    antlr4::tree::TerminalNode *NON_RETAIN();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Prog_ConfigContext* prog_Config();

  class  Prog_Conf_ElemsContext : public antlr4::ParserRuleContext {
  public:
    Prog_Conf_ElemsContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    std::vector<Prog_Conf_ElemContext *> prog_Conf_Elem();
    Prog_Conf_ElemContext* prog_Conf_Elem(size_t i);
    std::vector<antlr4::tree::TerminalNode *> Comma();
    antlr4::tree::TerminalNode* Comma(size_t i);

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Prog_Conf_ElemsContext* prog_Conf_Elems();

  class  Prog_Conf_ElemContext : public antlr4::ParserRuleContext {
  public:
    Prog_Conf_ElemContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    FB_TaskContext *fB_Task();
    Prog_CnxnContext *prog_Cnxn();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Prog_Conf_ElemContext* prog_Conf_Elem();

  class  FB_TaskContext : public antlr4::ParserRuleContext {
  public:
    FB_TaskContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    FB_Instance_NameContext *fB_Instance_Name();
    antlr4::tree::TerminalNode *WITH();
    Task_NameContext *task_Name();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  FB_TaskContext* fB_Task();

  class  Prog_CnxnContext : public antlr4::ParserRuleContext {
  public:
    Prog_CnxnContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    Symbolic_VariableContext *symbolic_Variable();
    antlr4::tree::TerminalNode *Assign();
    Prog_Data_SourceContext *prog_Data_Source();
    antlr4::tree::TerminalNode *LeftAssign();
    Data_SinkContext *data_Sink();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Prog_CnxnContext* prog_Cnxn();

  class  Prog_Data_SourceContext : public antlr4::ParserRuleContext {
  public:
    Prog_Data_SourceContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    ConstantContext *constant();
    Enum_ValueContext *enum_Value();
    Global_Var_AccessContext *global_Var_Access();
    antlr4::tree::TerminalNode *Direct_Variable();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Prog_Data_SourceContext* prog_Data_Source();

  class  Data_SinkContext : public antlr4::ParserRuleContext {
  public:
    Data_SinkContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    Global_Var_AccessContext *global_Var_Access();
    antlr4::tree::TerminalNode *Direct_Variable();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Data_SinkContext* data_Sink();

  class  Config_InitContext : public antlr4::ParserRuleContext {
  public:
    Config_InitContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *VAR_CONFIG();
    antlr4::tree::TerminalNode *END_VAR();
    std::vector<Config_Inst_InitContext *> config_Inst_Init();
    Config_Inst_InitContext* config_Inst_Init(size_t i);
    std::vector<antlr4::tree::TerminalNode *> Semi();
    antlr4::tree::TerminalNode* Semi(size_t i);

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Config_InitContext* config_Init();

  class  Config_Inst_InitContext : public antlr4::ParserRuleContext {
  public:
    Config_Inst_InitContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    Resource_NameContext *resource_Name();
    std::vector<antlr4::tree::TerminalNode *> Dot();
    antlr4::tree::TerminalNode* Dot(size_t i);
    Prog_NameContext *prog_Name();
    Variable_NameContext *variable_Name();
    antlr4::tree::TerminalNode *Colon();
    Loc_Var_Spec_InitContext *loc_Var_Spec_Init();
    antlr4::tree::TerminalNode *Assign();
    Struct_InitContext *struct_Init();
    std::vector<FB_Instance_NameContext *> fB_Instance_Name();
    FB_Instance_NameContext* fB_Instance_Name(size_t i);
    std::vector<Class_Instance_NameContext *> class_Instance_Name();
    Class_Instance_NameContext* class_Instance_Name(size_t i);
    Located_AtContext *located_At();
    FB_Type_AccessContext *fB_Type_Access();
    Class_Type_AccessContext *class_Type_Access();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Config_Inst_InitContext* config_Inst_Init();

  class  Namespace_DeclContext : public antlr4::ParserRuleContext {
  public:
    Namespace_DeclContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *NAMESPACE();
    Namespace_H_NameContext *namespace_H_Name();
    Namespace_ElementsContext *namespace_Elements();
    antlr4::tree::TerminalNode *END_NAMESPACE();
    antlr4::tree::TerminalNode *INTERNAL();
    std::vector<Using_DirectiveContext *> using_Directive();
    Using_DirectiveContext* using_Directive(size_t i);

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Namespace_DeclContext* namespace_Decl();

  class  Namespace_ElementsContext : public antlr4::ParserRuleContext {
  public:
    Namespace_ElementsContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    std::vector<Data_Type_DeclContext *> data_Type_Decl();
    Data_Type_DeclContext* data_Type_Decl(size_t i);
    std::vector<Func_DeclContext *> func_Decl();
    Func_DeclContext* func_Decl(size_t i);
    std::vector<FB_DeclContext *> fB_Decl();
    FB_DeclContext* fB_Decl(size_t i);
    std::vector<Class_DeclContext *> class_Decl();
    Class_DeclContext* class_Decl(size_t i);
    std::vector<Interface_DeclContext *> interface_Decl();
    Interface_DeclContext* interface_Decl(size_t i);
    std::vector<Namespace_DeclContext *> namespace_Decl();
    Namespace_DeclContext* namespace_Decl(size_t i);

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Namespace_ElementsContext* namespace_Elements();

  class  Namespace_H_NameContext : public antlr4::ParserRuleContext {
  public:
    Namespace_H_NameContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    std::vector<Namespace_NameContext *> namespace_Name();
    Namespace_NameContext* namespace_Name(size_t i);
    std::vector<antlr4::tree::TerminalNode *> Dot();
    antlr4::tree::TerminalNode* Dot(size_t i);

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Namespace_H_NameContext* namespace_H_Name();

  class  Using_DirectiveContext : public antlr4::ParserRuleContext {
  public:
    Using_DirectiveContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *USING();
    std::vector<Namespace_H_NameContext *> namespace_H_Name();
    Namespace_H_NameContext* namespace_H_Name(size_t i);
    antlr4::tree::TerminalNode *Semi();
    std::vector<antlr4::tree::TerminalNode *> Comma();
    antlr4::tree::TerminalNode* Comma(size_t i);

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Using_DirectiveContext* using_Directive();

  class  POU_DeclContext : public antlr4::ParserRuleContext {
  public:
    POU_DeclContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    std::vector<Using_DirectiveContext *> using_Directive();
    Using_DirectiveContext* using_Directive(size_t i);
    std::vector<Global_Var_DeclsContext *> global_Var_Decls();
    Global_Var_DeclsContext* global_Var_Decls(size_t i);
    std::vector<Data_Type_DeclContext *> data_Type_Decl();
    Data_Type_DeclContext* data_Type_Decl(size_t i);
    std::vector<Access_DeclsContext *> access_Decls();
    Access_DeclsContext* access_Decls(size_t i);
    std::vector<Func_DeclContext *> func_Decl();
    Func_DeclContext* func_Decl(size_t i);
    std::vector<FB_DeclContext *> fB_Decl();
    FB_DeclContext* fB_Decl(size_t i);
    std::vector<Class_DeclContext *> class_Decl();
    Class_DeclContext* class_Decl(size_t i);
    std::vector<Interface_DeclContext *> interface_Decl();
    Interface_DeclContext* interface_Decl(size_t i);
    std::vector<Namespace_DeclContext *> namespace_Decl();
    Namespace_DeclContext* namespace_Decl(size_t i);

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  POU_DeclContext* pOU_Decl();

  class  ExpressionContext : public antlr4::ParserRuleContext {
  public:
    ExpressionContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    std::vector<Xor_ExprContext *> xor_Expr();
    Xor_ExprContext* xor_Expr(size_t i);
    std::vector<antlr4::tree::TerminalNode *> OR();
    antlr4::tree::TerminalNode* OR(size_t i);

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  ExpressionContext* expression();

  class  Constant_ExprContext : public antlr4::ParserRuleContext {
  public:
    Constant_ExprContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    ExpressionContext *expression();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Constant_ExprContext* constant_Expr();

  class  Xor_ExprContext : public antlr4::ParserRuleContext {
  public:
    Xor_ExprContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    std::vector<And_ExprContext *> and_Expr();
    And_ExprContext* and_Expr(size_t i);
    std::vector<antlr4::tree::TerminalNode *> XOR();
    antlr4::tree::TerminalNode* XOR(size_t i);

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Xor_ExprContext* xor_Expr();

  class  And_ExprContext : public antlr4::ParserRuleContext {
  public:
    And_ExprContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    std::vector<Compare_ExprContext *> compare_Expr();
    Compare_ExprContext* compare_Expr(size_t i);
    std::vector<antlr4::tree::TerminalNode *> AndSign();
    antlr4::tree::TerminalNode* AndSign(size_t i);
    std::vector<antlr4::tree::TerminalNode *> AND();
    antlr4::tree::TerminalNode* AND(size_t i);

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  And_ExprContext* and_Expr();

  class  Compare_ExprContext : public antlr4::ParserRuleContext {
  public:
    Compare_ExprContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    std::vector<Equ_ExprContext *> equ_Expr();
    Equ_ExprContext* equ_Expr(size_t i);
    std::vector<antlr4::tree::TerminalNode *> Equal();
    antlr4::tree::TerminalNode* Equal(size_t i);
    std::vector<antlr4::tree::TerminalNode *> NotEqual();
    antlr4::tree::TerminalNode* NotEqual(size_t i);

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Compare_ExprContext* compare_Expr();

  class  Equ_ExprContext : public antlr4::ParserRuleContext {
  public:
    Equ_ExprContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    std::vector<Add_ExprContext *> add_Expr();
    Add_ExprContext* add_Expr(size_t i);
    std::vector<antlr4::tree::TerminalNode *> Less();
    antlr4::tree::TerminalNode* Less(size_t i);
    std::vector<antlr4::tree::TerminalNode *> Greater();
    antlr4::tree::TerminalNode* Greater(size_t i);
    std::vector<antlr4::tree::TerminalNode *> LessEqual();
    antlr4::tree::TerminalNode* LessEqual(size_t i);
    std::vector<antlr4::tree::TerminalNode *> GreaterEqual();
    antlr4::tree::TerminalNode* GreaterEqual(size_t i);

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Equ_ExprContext* equ_Expr();

  class  Add_ExprContext : public antlr4::ParserRuleContext {
  public:
    Add_ExprContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    std::vector<TermContext *> term();
    TermContext* term(size_t i);
    std::vector<antlr4::tree::TerminalNode *> Plus();
    antlr4::tree::TerminalNode* Plus(size_t i);
    std::vector<antlr4::tree::TerminalNode *> Minus();
    antlr4::tree::TerminalNode* Minus(size_t i);

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Add_ExprContext* add_Expr();

  class  TermContext : public antlr4::ParserRuleContext {
  public:
    TermContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    std::vector<Power_ExprContext *> power_Expr();
    Power_ExprContext* power_Expr(size_t i);
    std::vector<antlr4::tree::TerminalNode *> Star();
    antlr4::tree::TerminalNode* Star(size_t i);
    std::vector<antlr4::tree::TerminalNode *> Div();
    antlr4::tree::TerminalNode* Div(size_t i);
    std::vector<antlr4::tree::TerminalNode *> MOD();
    antlr4::tree::TerminalNode* MOD(size_t i);

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  TermContext* term();

  class  Power_ExprContext : public antlr4::ParserRuleContext {
  public:
    Power_ExprContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    std::vector<Unary_ExprContext *> unary_Expr();
    Unary_ExprContext* unary_Expr(size_t i);
    std::vector<antlr4::tree::TerminalNode *> StarStar();
    antlr4::tree::TerminalNode* StarStar(size_t i);

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Power_ExprContext* power_Expr();

  class  Unary_ExprContext : public antlr4::ParserRuleContext {
  public:
    Unary_ExprContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *Minus();
    antlr4::tree::TerminalNode *Plus();
    Primary_ExprContext *primary_Expr();
    antlr4::tree::TerminalNode *NOT();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Unary_ExprContext* unary_Expr();

  class  Paren_Surrounded_ExprContext : public antlr4::ParserRuleContext {
  public:
    Paren_Surrounded_ExprContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *LeftParen();
    ExpressionContext *expression();
    antlr4::tree::TerminalNode *RightParen();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Paren_Surrounded_ExprContext* paren_Surrounded_Expr();

  class  Primary_ExprContext : public antlr4::ParserRuleContext {
  public:
    Primary_ExprContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    ConstantContext *constant();
    IdentifierContext *identifier();
    Enum_ValueContext *enum_Value();
    Variable_AccessContext *variable_Access();
    Func_CallContext *func_Call();
    Ref_ValueContext *ref_Value();
    Paren_Surrounded_ExprContext *paren_Surrounded_Expr();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Primary_ExprContext* primary_Expr();

  class  Variable_AccessContext : public antlr4::ParserRuleContext {
  public:
    Variable_AccessContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    VariableContext *variable();
    antlr4::tree::TerminalNode *Multibit_Part_Access();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Variable_AccessContext* variable_Access();

  class  Callable_Obj_Params_AssignContext : public antlr4::ParserRuleContext {
  public:
    Callable_Obj_Params_AssignContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *LeftParen();
    antlr4::tree::TerminalNode *RightParen();
    std::vector<Param_AssignContext *> param_Assign();
    Param_AssignContext* param_Assign(size_t i);
    std::vector<antlr4::tree::TerminalNode *> Comma();
    antlr4::tree::TerminalNode* Comma(size_t i);

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Callable_Obj_Params_AssignContext* callable_Obj_Params_Assign();

  class  Func_CallContext : public antlr4::ParserRuleContext {
  public:
    Func_CallContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    Func_AccessContext *func_Access();
    Callable_Obj_Params_AssignContext *callable_Obj_Params_Assign();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Func_CallContext* func_Call();

  class  Stmt_ListContext : public antlr4::ParserRuleContext {
  public:
    Stmt_ListContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    std::vector<antlr4::tree::TerminalNode *> Semi();
    antlr4::tree::TerminalNode* Semi(size_t i);
    std::vector<StmtContext *> stmt();
    StmtContext* stmt(size_t i);

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Stmt_ListContext* stmt_List();

  class  StmtContext : public antlr4::ParserRuleContext {
  public:
    StmtContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    Assign_StmtContext *assign_Stmt();
    Subprog_Ctrl_StmtContext *subprog_Ctrl_Stmt();
    Selection_StmtContext *selection_Stmt();
    Iteration_StmtContext *iteration_Stmt();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  StmtContext* stmt();

  class  Assign_StmtContext : public antlr4::ParserRuleContext {
  public:
    Assign_StmtContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    Var_AssignContext *var_Assign();
    Ref_AssignContext *ref_Assign();
    Assignment_AttemptContext *assignment_Attempt();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Assign_StmtContext* assign_Stmt();

  class  Var_AssignContext : public antlr4::ParserRuleContext {
  public:
    Var_AssignContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    VariableContext *variable();
    antlr4::tree::TerminalNode *Assign();
    ExpressionContext *expression();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Var_AssignContext* var_Assign();

  class  Assignment_AttemptContext : public antlr4::ParserRuleContext {
  public:
    Assignment_AttemptContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *QuestionEqual();
    std::vector<Ref_NameContext *> ref_Name();
    Ref_NameContext* ref_Name(size_t i);
    std::vector<Ref_DerefContext *> ref_Deref();
    Ref_DerefContext* ref_Deref(size_t i);
    Ref_ValueContext *ref_Value();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Assignment_AttemptContext* assignment_Attempt();

  class  Inside_Callable_ObjContext : public antlr4::ParserRuleContext {
  public:
    Inside_Callable_ObjContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    Method_NameContext *method_Name();
    antlr4::tree::TerminalNode *THIS();
    std::vector<antlr4::tree::TerminalNode *> Dot();
    antlr4::tree::TerminalNode* Dot(size_t i);
    std::vector<FB_Instance_NameContext *> fB_Instance_Name();
    FB_Instance_NameContext* fB_Instance_Name(size_t i);
    std::vector<Class_Instance_NameContext *> class_Instance_Name();
    Class_Instance_NameContext* class_Instance_Name(size_t i);

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Inside_Callable_ObjContext* inside_Callable_Obj();

  class  Callable_ObjContext : public antlr4::ParserRuleContext {
  public:
    Callable_ObjContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    FB_Instance_NameContext *fB_Instance_Name();
    Method_NameContext *method_Name();
    antlr4::tree::TerminalNode *THIS();
    Inside_Callable_ObjContext *inside_Callable_Obj();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Callable_ObjContext* callable_Obj();

  class  InvocationContext : public antlr4::ParserRuleContext {
  public:
    InvocationContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    Callable_ObjContext *callable_Obj();
    Callable_Obj_Params_AssignContext *callable_Obj_Params_Assign();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  InvocationContext* invocation();

  class  Subprog_Ctrl_StmtContext : public antlr4::ParserRuleContext {
  public:
    Subprog_Ctrl_StmtContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    Func_CallContext *func_Call();
    InvocationContext *invocation();
    antlr4::tree::TerminalNode *SUPER();
    antlr4::tree::TerminalNode *LeftParen();
    antlr4::tree::TerminalNode *RightParen();
    antlr4::tree::TerminalNode *RETURN();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Subprog_Ctrl_StmtContext* subprog_Ctrl_Stmt();

  class  Param_AssignContext : public antlr4::ParserRuleContext {
  public:
    Param_AssignContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    Common_Param_AssignContext *common_Param_Assign();
    Ref_Param_AssignContext *ref_Param_Assign();
    Other_Param_AssignContext *other_Param_Assign();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Param_AssignContext* param_Assign();

  class  Common_Param_AssignContext : public antlr4::ParserRuleContext {
  public:
    Common_Param_AssignContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    ExpressionContext *expression();
    Variable_NameContext *variable_Name();
    antlr4::tree::TerminalNode *Assign();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Common_Param_AssignContext* common_Param_Assign();

  class  Ref_Param_AssignContext : public antlr4::ParserRuleContext {
  public:
    Ref_Param_AssignContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    Ref_AssignContext *ref_Assign();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Ref_Param_AssignContext* ref_Param_Assign();

  class  Other_Param_AssignContext : public antlr4::ParserRuleContext {
  public:
    Other_Param_AssignContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    Variable_NameContext *variable_Name();
    antlr4::tree::TerminalNode *LeftAssign();
    VariableContext *variable();
    antlr4::tree::TerminalNode *NOT();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Other_Param_AssignContext* other_Param_Assign();

  class  Selection_StmtContext : public antlr4::ParserRuleContext {
  public:
    Selection_StmtContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    IF_StmtContext *iF_Stmt();
    Case_StmtContext *case_Stmt();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Selection_StmtContext* selection_Stmt();

  class  IF_StmtContext : public antlr4::ParserRuleContext {
  public:
    IF_StmtContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *IF();
    std::vector<ExpressionContext *> expression();
    ExpressionContext* expression(size_t i);
    std::vector<antlr4::tree::TerminalNode *> THEN();
    antlr4::tree::TerminalNode* THEN(size_t i);
    std::vector<Stmt_ListContext *> stmt_List();
    Stmt_ListContext* stmt_List(size_t i);
    antlr4::tree::TerminalNode *END_IF();
    std::vector<antlr4::tree::TerminalNode *> ELSIF();
    antlr4::tree::TerminalNode* ELSIF(size_t i);
    antlr4::tree::TerminalNode *ELSE();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  IF_StmtContext* iF_Stmt();

  class  Case_StmtContext : public antlr4::ParserRuleContext {
  public:
    Case_StmtContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *CASE();
    ExpressionContext *expression();
    antlr4::tree::TerminalNode *OF();
    antlr4::tree::TerminalNode *END_CASE();
    std::vector<Case_SelectionContext *> case_Selection();
    Case_SelectionContext* case_Selection(size_t i);
    antlr4::tree::TerminalNode *ELSE();
    Stmt_ListContext *stmt_List();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Case_StmtContext* case_Stmt();

  class  Case_SelectionContext : public antlr4::ParserRuleContext {
  public:
    Case_SelectionContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    Case_ListContext *case_List();
    antlr4::tree::TerminalNode *Colon();
    Stmt_ListContext *stmt_List();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Case_SelectionContext* case_Selection();

  class  Case_ListContext : public antlr4::ParserRuleContext {
  public:
    Case_ListContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    std::vector<Case_List_ElemContext *> case_List_Elem();
    Case_List_ElemContext* case_List_Elem(size_t i);
    std::vector<antlr4::tree::TerminalNode *> Comma();
    antlr4::tree::TerminalNode* Comma(size_t i);

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Case_ListContext* case_List();

  class  Case_List_ElemContext : public antlr4::ParserRuleContext {
  public:
    Case_List_ElemContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    SubrangeContext *subrange();
    Constant_ExprContext *constant_Expr();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Case_List_ElemContext* case_List_Elem();

  class  Iteration_StmtContext : public antlr4::ParserRuleContext {
  public:
    Iteration_StmtContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    For_StmtContext *for_Stmt();
    While_StmtContext *while_Stmt();
    Repeat_StmtContext *repeat_Stmt();
    antlr4::tree::TerminalNode *EXIT();
    antlr4::tree::TerminalNode *CONTINUE();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Iteration_StmtContext* iteration_Stmt();

  class  For_StmtContext : public antlr4::ParserRuleContext {
  public:
    For_StmtContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *FOR();
    Control_VariableContext *control_Variable();
    antlr4::tree::TerminalNode *Assign();
    For_ListContext *for_List();
    antlr4::tree::TerminalNode *DO();
    Stmt_ListContext *stmt_List();
    antlr4::tree::TerminalNode *END_FOR();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  For_StmtContext* for_Stmt();

  class  For_ListContext : public antlr4::ParserRuleContext {
  public:
    For_ListContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    std::vector<ExpressionContext *> expression();
    ExpressionContext* expression(size_t i);
    antlr4::tree::TerminalNode *TO();
    antlr4::tree::TerminalNode *BY();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  For_ListContext* for_List();

  class  While_StmtContext : public antlr4::ParserRuleContext {
  public:
    While_StmtContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *WHILE();
    ExpressionContext *expression();
    antlr4::tree::TerminalNode *DO();
    Stmt_ListContext *stmt_List();
    antlr4::tree::TerminalNode *END_WHILE();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  While_StmtContext* while_Stmt();

  class  Repeat_StmtContext : public antlr4::ParserRuleContext {
  public:
    Repeat_StmtContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *REPEAT();
    Stmt_ListContext *stmt_List();
    antlr4::tree::TerminalNode *UNTIL();
    ExpressionContext *expression();
    antlr4::tree::TerminalNode *END_REPEAT();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Repeat_StmtContext* repeat_Stmt();

  class  Simple_Type_NameContext : public antlr4::ParserRuleContext {
  public:
    Simple_Type_NameContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    IdentifierContext *identifier();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Simple_Type_NameContext* simple_Type_Name();

  class  Subrange_Type_NameContext : public antlr4::ParserRuleContext {
  public:
    Subrange_Type_NameContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    IdentifierContext *identifier();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Subrange_Type_NameContext* subrange_Type_Name();

  class  Enum_Type_NameContext : public antlr4::ParserRuleContext {
  public:
    Enum_Type_NameContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    IdentifierContext *identifier();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Enum_Type_NameContext* enum_Type_Name();

  class  Array_Type_NameContext : public antlr4::ParserRuleContext {
  public:
    Array_Type_NameContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    IdentifierContext *identifier();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Array_Type_NameContext* array_Type_Name();

  class  Struct_Type_NameContext : public antlr4::ParserRuleContext {
  public:
    Struct_Type_NameContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    IdentifierContext *identifier();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Struct_Type_NameContext* struct_Type_Name();

  class  Struct_Elem_NameContext : public antlr4::ParserRuleContext {
  public:
    Struct_Elem_NameContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    IdentifierContext *identifier();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Struct_Elem_NameContext* struct_Elem_Name();

  class  Ref_NameContext : public antlr4::ParserRuleContext {
  public:
    Ref_NameContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    IdentifierContext *identifier();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Ref_NameContext* ref_Name();

  class  Ref_Type_NameContext : public antlr4::ParserRuleContext {
  public:
    Ref_Type_NameContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    IdentifierContext *identifier();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Ref_Type_NameContext* ref_Type_Name();

  class  Variable_NameContext : public antlr4::ParserRuleContext {
  public:
    Variable_NameContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    IdentifierContext *identifier();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Variable_NameContext* variable_Name();

  class  FB_NameContext : public antlr4::ParserRuleContext {
  public:
    FB_NameContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    IdentifierContext *identifier();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  FB_NameContext* fB_Name();

  class  Global_Var_NameContext : public antlr4::ParserRuleContext {
  public:
    Global_Var_NameContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    IdentifierContext *identifier();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Global_Var_NameContext* global_Var_Name();

  class  Derived_Func_NameContext : public antlr4::ParserRuleContext {
  public:
    Derived_Func_NameContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    IdentifierContext *identifier();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Derived_Func_NameContext* derived_Func_Name();

  class  Derived_FB_NameContext : public antlr4::ParserRuleContext {
  public:
    Derived_FB_NameContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    IdentifierContext *identifier();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Derived_FB_NameContext* derived_FB_Name();

  class  Method_NameContext : public antlr4::ParserRuleContext {
  public:
    Method_NameContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    IdentifierContext *identifier();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Method_NameContext* method_Name();

  class  Class_Type_NameContext : public antlr4::ParserRuleContext {
  public:
    Class_Type_NameContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    IdentifierContext *identifier();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Class_Type_NameContext* class_Type_Name();

  class  Class_NameContext : public antlr4::ParserRuleContext {
  public:
    Class_NameContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    IdentifierContext *identifier();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Class_NameContext* class_Name();

  class  Interface_Type_NameContext : public antlr4::ParserRuleContext {
  public:
    Interface_Type_NameContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    IdentifierContext *identifier();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Interface_Type_NameContext* interface_Type_Name();

  class  Prog_Type_NameContext : public antlr4::ParserRuleContext {
  public:
    Prog_Type_NameContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    IdentifierContext *identifier();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Prog_Type_NameContext* prog_Type_Name();

  class  Step_NameContext : public antlr4::ParserRuleContext {
  public:
    Step_NameContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    IdentifierContext *identifier();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Step_NameContext* step_Name();

  class  Action_NameContext : public antlr4::ParserRuleContext {
  public:
    Action_NameContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    IdentifierContext *identifier();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Action_NameContext* action_Name();

  class  Transition_NameContext : public antlr4::ParserRuleContext {
  public:
    Transition_NameContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    IdentifierContext *identifier();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Transition_NameContext* transition_Name();

  class  Config_NameContext : public antlr4::ParserRuleContext {
  public:
    Config_NameContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    IdentifierContext *identifier();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Config_NameContext* config_Name();

  class  Resource_Type_NameContext : public antlr4::ParserRuleContext {
  public:
    Resource_Type_NameContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    IdentifierContext *identifier();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Resource_Type_NameContext* resource_Type_Name();

  class  Resource_NameContext : public antlr4::ParserRuleContext {
  public:
    Resource_NameContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    IdentifierContext *identifier();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Resource_NameContext* resource_Name();

  class  Access_NameContext : public antlr4::ParserRuleContext {
  public:
    Access_NameContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    IdentifierContext *identifier();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Access_NameContext* access_Name();

  class  Prog_NameContext : public antlr4::ParserRuleContext {
  public:
    Prog_NameContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    IdentifierContext *identifier();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Prog_NameContext* prog_Name();

  class  Task_NameContext : public antlr4::ParserRuleContext {
  public:
    Task_NameContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    IdentifierContext *identifier();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Task_NameContext* task_Name();

  class  Namespace_NameContext : public antlr4::ParserRuleContext {
  public:
    Namespace_NameContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    IdentifierContext *identifier();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Namespace_NameContext* namespace_Name();

  class  Control_VariableContext : public antlr4::ParserRuleContext {
  public:
    Control_VariableContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    IdentifierContext *identifier();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Control_VariableContext* control_Variable();

  class  Indicator_NameContext : public antlr4::ParserRuleContext {
  public:
    Indicator_NameContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    Variable_NameContext *variable_Name();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Indicator_NameContext* indicator_Name();

  class  IdentifierContext : public antlr4::ParserRuleContext {
  public:
    IdentifierContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *Identifier();
    antlr4::tree::TerminalNode *ACTION_QUALIFIER();
    antlr4::tree::TerminalNode *ACTION_TIME_QUALIFIER();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  IdentifierContext* identifier();


  // By default the static state used to implement the parser is lazily initialized during the first
  // call to the constructor. You can call this function if you wish to initialize the static state
  // ahead of time.
  static void initialize();

private:
};

}  // namespace plcst
